Criar e Executar um Aplicativo


Criando um aplicativo do Flet

Instruções para o instalação do Git podem ser vista em
Git e GitHub, nesse site.

O flet inclui uma rotina que pode ser usada para gerar um aplicativo mínimo, que pode ser aumentado com os widgets e comandos do usuário. Para usar a criação automática do projeto básico é necessário ter o git instalado no computador. Após ter os requisitos instalados executamos flet create que gera um esqueleto básico de um aplicativo, contendo alguns widgets:

# Para criar o aplicativo de nome <teste> crie um diretório com esse nome e mude para ele
$ mkdir teste
$ cd teste

# o aplicativo pode ser criado apenas com
$ flet create

# o aplicativo pode ser rodado com
$ flet run

Essas ações geram a seguinte estrutura de diretórios:

  • src/main.py é o ponto de entrada do aplicativo Flet. Nele se pode colocar uma página ou janela (objetos containers do flet) contendo ramificações para outras páginas, botões e componentes de exibição de conteúdo. Ele termina com flet.app(main), o que inicializa e roda o aplicativo. É possível definir um ponto de entrada diferente especificando no argumento --module-name <argumento>.
  • assets é um diretório [opcional] que contém arquivos auxiliares do aplicativo, como imagens, som, texto e outros arquivos necessários. Ele também pode conter imagens usadas como ícones de pacotes e telas iniciais. Se existir apenas o ícone icon.png (que pode ser nos formatos suportados como .bmp, .jpg, .webp) ele será usado como uma imagem de origem para gerar todos os ícones e telas iniciais para todas as plataformas.
  • pyproject.toml contém os metadados do aplicativo, com uma lista suas dependências. Ele controla o processo de compilação. A lista de dependências do projeto deve conter pelo menos o pacote flet.
Caso se use o gerenciador de ambiente uv o comando é uv run flet create.
Usando o gerenciador de ambiente poetry o comando é poetry run flet create.

Um projeto de aplicativo pode ser criado diretamente (sem a existência prévia do diretório).

# para criar um aplicativo com o nome <nome_do_projeto>
# <nome_do_projeto> será usado como nome do diretório que recebe o aplicativo.
$ flet create <meu_aplicativo_flet>

# para criar um aplicativo basedo no modelo "contador", execute:
$ flet create --template contador <nome_do_projeto>

# para criar o aplicativo a partir do modelo, no diretório atual, execute:
$ flet criar --template contador .

O Flet criará o diretório <nome_do_projeto> contendo o arquivo main.py:

import flet as ft

def main(page: ft.Page):
    page.add(ft.SafeArea(ft.Text("Hello, Flet!")))

ft.app(main)

No corpo da função main() podemos adicionar elementos de UI (controles) e código a ser executado. O código termina com a função ft.app(main) que inicializa o aplicativo Flet e executa main().

Rodando o Aplicativo

Rodando no destop: Para rodar o aplicativo no desktop basta executar:

# roda main.py no diretório atual
$ flet run
# esse comando executará main.py localizado no diretório atual

# se for necessário especificar um caminho diferente:
$ flet run [script]
# que executará main.py no diretório especificado

# para executar main.py em um diretório que não o atual, pode ser fornecido o caminho completo, absoluto ou relativo, para o diretório
# onde está o arquivo main.py. Por exemplo:
$ flet run /Users/Usuario/Projetos/flet-app

# o arquivo principal não preisa ser main.py:
$ flet run contador.py

Em qualquer dos casos o aplicativo será iniciado em janela nativa do sistema operacional usado.

Rodando no navegador: Para rodar um aplicativo como app da web (no navegador, portanto) usamos o comando:

$ flet run --web [script]
# uma nova janela (ou aba) será aberta no navegador, usando uma porta aleatória.

# para selecionar uma porta específica use a opção  --port (-p). Por ex.:
$ flet run --web --port 8000 app.py

Recarregamento automático: Por default o Flet carregará e rodará o arquivo principal, carregando novamente sempre que esse arquivo for alterado e gravado. No entanto a aplicativo em execução não será afetado por alterações em outros arquivos no projeto. Para que todos os arquivos sejam recarregados quando alterados usamos:

$ poetry run flet run -d [script]

# para que sub-diretórios sejam incluídos recursivamente use:
$ poetry run flet run -d -r [script]

Sintaxe do comando run

O comando run é usado para executar aplicativos do Flet e tem a seguinte sintaxe:

flet run [-h] [-v] [-p PORT] [--host HOST] [--name APP_NAME]
         [-m] [-d] [-r] [-n] [-w][--ios] [--android] [-a ASSETS_DIR]
         [--ignore-dirs IGNORE_DIRS] [script]

script é um argumento posicional, servindo para designar o caminho do script Python.

As demais opções estão listadas na tabela abaixo.

Argumento Significado
-h, --help mostra essa mensagem de ajuda e termina
-v, --verbose -v para saída detalhada e -vv para mais detalhes
-p PORT, --port PORT Porta TCP personalizada para execução do aplicativo
--host HOST host para execução do aplicativo web. Use “*” para escutar em todos os IPs.
--name APP_NAME nome do aplicativo para distingui-lo de outros apps na mesma porta
-m, --module trata o script como um caminho de módulo python, e não como caminho de arquivo
-d, --directory observar o diretório de script
-r, --recursive observar diretório e subdiretórios de script recursivamente
-n, --hidden manter a janela do aplicativo oculta na inicialização
-w, --web abrir aplicativo em um navegador da web
--ios abrir aplicativo em dispositivo iOS
--android abrir aplicativo no dispositivo Android
-a ASSETS_DIR, --assets ASSETS_DIR caminho para o diretório de assets
--ignore-dirs IGNORE_DIRS diretórios ignorados durante a observação. Para mais de um, separe com vírgulas.

Notas: † Observar, nesse caso, é estar ciente de que houve alterações no código usado para recarregamento automático, descrito acima.

Inserindo Widgets

Para obter alguma funcionalidade em nosso aplicativo temos que inserir nele controles, também chamados de widgets. Controles são inseridas na Page, o widget de nível mais alto, ou aninhados dentro de outros controles. Por exemplo, para inserir texto diretamente na page fazemos:

import flet as ft

def main(page=ft.Page):
    txt = ft.Text(value="Olá mundo!", color="blue")
    page.controls.append(txt)
    page.update()

ft.app(target=main)


Widgets são objetos do python com uma representação visual, com características controladas por seus parâmetros. value e color são parâmetros que recebem strings, esse último declarado no formato de cor do HTML. São válidas as cores, por exemplo: navyblue, #ff0000 (vermelho), etc. O objeto page possui uma lista controls, à qual adicionamos o elemento txt.

No código seguinte usamos um atalho: page.add(t) significa o mesmo que page.controls.append(t) seguido de page.update(). Também importamos o módulo time para provocar uma pausa na execução do código em time.sleep(1).

import flet as ft
import time

def main(page=ft.Page):
    t = ft.Text()
    page.add(t)
    cidades = ["Belo Horizonte","Curitiba","São Paulo","Salvador","** fim **"]
    for i in range(5):
        t.value = cidades[i]
        page.update()
        time.sleep(1)

ft.app(target=main)

Ao ser executado as quatro cidades armazenadas na lista cidades são exibidas e o loop é terminado com a exibição de ** fim **.


Alguns controles, como Row e Line são containers, podendo conter dentro deles outros widgets, da mesma forma que Page. Por exemplo, inicializamos abaixo uma linha (um objeto ft.Row) contendo três outros objetos que são strings, e a inserimos em page.

import flet as ft
import time

def main(page=ft.Page):
    linha = ft.Row(controls=[ft.Text("Estas são"), ft.Text("cidades"), ft.Text("brasileiras")])
    page.add(linha)
    t = ft.Text()
    page.add(t) # it's a shortcut for page.controls.append(t) and then page.update()
    cidades = ["Belo Horizonte","Curitiba","São Paulo","Salvador","** fim **"]
    for i in range(5):
        t.value = cidades[i]
        page.update()
        time.sleep(1)

ft.app(target=main)

O resultado é exibido na figura 1, com a cidade sendo substituída a cada momento. A linha page.update() é necessária pois o valor do ft.Text() foi alterado.

Figura 1

Vemos que Row recebe no parâmetro controls  uma lista com 3 widgets de texto.

Claro que muitos outros controles pode ser inseridos. Com o bloco abaixo podemos inserir um campo de texto, que pode ser editado pelo usuário, e um botão.

    page.add(
        ft.Row(controls=[
            ft.TextField(label="Sua cidade"),
            ft.ElevatedButton(text="Clique aqui para inserir o nome de sua cidade!")
        ])
    )

Podemos também criar novas entradas de texto e as inserir consecutivamente em page.

import flet as ft
import time

def main(page=ft.Page):
    page.add(ft.Row(controls=[ft.Text("Estas são cidades brasileiras")]))
    cidades = ["Belo Horizonte","Curitiba","São Paulo","Salvador","** fim **"]
    for i in range(5):
        t = ft.Text()
        t.value = cidades[i]
        page.add(t)
        page.update()
        time.sleep(1)

ft.app(target=main)
Figura 2

Nesse caso não estamos substituindo o conteúdo de um objeto de texto fixo na página, e sim inserindo novas linhas (figura 2). Observe que nenhum procedimento foi designado a esse botão que, no momento, não executa nenhuma tarefa.

O comando page.update(), que pode estar embutido em page.add(), envia para a página renderizada apenas as alterações feitas desde sua última execução.

Observe que o argumento controls, aqui usado em Row é um argumento posicional noemado. O nome pode ser omitido se o argumento aparecer no primreiro lugar. Ou seja:

# a linha
ft.Row(controls=[ft.Text("Estas são cidades brasileiras")])
# pode ser escrita como
ft.Row([ft.Text("Estas são cidades brasileiras")])

# se outros argumentos estão presentes, controls deve aparecer primeiro
page.add(ft.Row([ft.Text("Estas são cidades brasileiras")], wrap=True))           # certo!
page.add(ft.Row(wrap=True, [ft.Text("Estas são cidades brasileiras")]))           # erro!
page.add(ft.Row(wrap=True, controls=[ft.Text("Estas são cidades brasileiras")]))  # certo!


Para incluir alguma ação útil em nosso projeto usamos a capacidade de alguns controles de lidar com eventos (os chamados event handlers). Botões podem executar tarefas quando são clicados usando o evento on_click.

import flet as ft
def main(page: ft.Page):
    def button_clicked(e):
        page.add(ft.Text("Clicou"))
        
    page.add(ft.ElevatedButton(text="Clica aqui", on_click=button_clicked))

ft.app(target=main)

Esse código associa a função button_clicked() com o evento on_click do botão. A cada clique um novo elemento de texto é colocado na página.

Várias outras propriedades podem ser usadas para alterar a aparência dos controles. Vamos usar width (largura) no código abaixo, além do controle Checkbox, uma caixa de texto que pode ser marcada. A função entrar_tarefa() verifica se há conteúdo em nova_tarefa, um TextField e, se houver, cria e insere na página uma nova Checkbox.
Depois limpa o valor de nova_tarefa. O comando nova_tarefa.focus() coloca no comando de texto o foco da ação dentro da página, independente de ela ter ou não sido usada no if.

import flet as ft

def main(page):
    def entrar_tarefa(e):
        if nova_tarefa.value:
            page.add(ft.Checkbox(label=nova_tarefa.value))
            nova_tarefa.value = ""            
        nova_tarefa.focus()

    nova_tarefa = ft.TextField(hint_text="Digite sua nova tarefa...", width=400)
    page.add(ft.Row([nova_tarefa, ft.ElevatedButton("Inserir tarefa", on_click=entrar_tarefa, width=300)]))
    nova_tarefa.focus()

ft.app(target=main)

É claro que muitas outras ações podem ser inseridas nesse pequeno programa, tal como testar se uma entrada já existe, eliminar espaços em branco desnecessários ou gravar as tarefas em um banco de dados.

Exemplo: Controles e propriedades

É comum os tutoriais do Flet apresentarem um pequeno bloco ilustrativo de código com a operação de somar e subtrair uma unidade a um número em uma caixa de texto. Mostramos aqui um código um pouco mais elaborado para apresentar propriedades adicionais. Usamos page.title = "Soma e subtrai" para inserir um título na barra de tarefas (ou na aba do navegador, se o codigo for executado no modo web), as propriedades de alignment. Além disso declaramos os botões e caixas de texto separadamente e depois os inserimos nas linhas.

import flet as ft

def main(page: ft.Page):
    def operar(e):
        numero = int(txt_number.value) + int(e.control.text)
        txt_number.value = str(numero)
        txt_operacao.value = "soma"
        page.update()

    def mult(e):
        numero =int(txt_number.value) * int(e.control.text.replace("*",""))
        txt_number.value = str(numero)
        txt_operacao.value = "multiplica"
        page.update()

    page.title = "Soma, subtrai, multiplica"
    txt_number = ft.TextField(value="0", text_align=ft.TextAlign.RIGHT, width=100)
    txt_info = ft.Text("Você pode somar ou subtrair 1 ou 10, multiplicar por 2, 3, 5, 7")
    txt_operacao = ft.TextField(value="", text_align=ft.TextAlign.RIGHT, width=100)
    
    bt1 = ft.ElevatedButton("-10", on_click=operar, width=100)
    bt2 = ft.ElevatedButton("-1", on_click=operar, width=100)
    bt3 = ft.ElevatedButton("+1", on_click=operar, width=100)
    bt4 = ft.ElevatedButton("+10", on_click=operar, width=100)    

    bt5 = ft.ElevatedButton("*2", on_click=mult, width=100)
    bt6 = ft.ElevatedButton("*3", on_click=mult, width=100)
    bt7 = ft.ElevatedButton("*5", on_click=mult, width=100)
    bt8 = ft.ElevatedButton("*7", on_click=mult, width=100)

    page.add(ft.Row([txt_info], alignment=ft.MainAxisAlignment.CENTER))
    page.add(ft.Row([bt1, bt2, txt_number, bt3, bt4], alignment=ft.MainAxisAlignment.CENTER))
    page.add(ft.Row([bt5, bt6, txt_operacao, bt7, bt8], alignment=ft.MainAxisAlignment.CENTER))

ft.app(main)

O resultado do código é mostrado na figura 3.

Figura 3

Observe que, ao se clicar nos botões de soma, por ex., o evento on_click chama a função operar(e) passando para ela o parâmetro e, que é um objeto de evento. Este objeto tem propriedades que usamos nas funções de chamada. Na soma (e subtração) capturamos e.control.text, a propriedade de texto exibida nesse botão (-1, +1, etc.). e a usamos para fazer a operação requerida. Os controles possuem diversas propriedades e respondem a eventos específicos, que devemos manipular para contruir a aparência e funcionalidade da interface gráfica.

Vale ainda mencionar que construímos as linhas com a sintaxe ft.Row([bt1, bt2, txt_number, bt3, bt4]), usando uma lista de controles previamente definidos. Essa lista está na primeira posição, onde se insere o valor do parâmetro nomeado controls. Se esse parâmetro não estiver na primeira entrada seu nome deve ser fornecido, como em: page.add(ft.Row(alignment=ft.MainAxisAlignment.CENTER, controls=[txt_info])).

Em uma questão meramente de estilo mas que pode facilitar a organização e leitura do código, podemos definir as linhas separadamente e depois inserí-las na página.

    linha1 = ft.Row([txt_info], alignment=ft.MainAxisAlignment.CENTER)
    linha2 = ft.Row(controls=[bt1, bt2, txt_number, bt3, bt4], alignment=ft.MainAxisAlignment.CENTER)
    linha3 = ft.Row(controls=[bt5, bt6, txt_operacao, bt7, bt8],
             alignment=ft.MainAxisAlignment.CENTER)

    page.add(linha1, linha2, linha3)


Python com Flet: Widgets

 

Flet: NavigationRail

NavigationRail

NavigationRail é um controle de navegação que pode ser exibido ao lado (direito ou esquerdo) de um controle principal, servindo como um menu de escolha entre algumas poucas opções.

Exemplo básico

O exemplo abaixo mostra um aplicativo com uma linha (ft.Row) contendo uma ft.NavigationRail, uma linha divisória e uma coluna com um único texto. A ft.NavigationRail, por sua vêz, contém um texto inicial, 3 controles ft.NavigationRailDestination e um texto final.

import flet as ft
def main(page: ft.Page):
    page.bgcolor=ft.Colors.GREY_400
    page.add(
        ft.Row([
            ft.NavigationRail(
                leading=ft.Text("Início"),
                destinations=[
                    ft.NavigationRailDestination(icon=ft.Icons.WOMAN, label="Mulher"),
                    ft.NavigationRailDestination(icon=ft.Icons.MAN, label="Homem"),
                    ft.NavigationRailDestination(icon=ft.Icons.CHILD_FRIENDLY, label="Criança")
                ],
                trailing=ft.Text("Final")
            ),            
            ft.VerticalDivider(width=1),
            ft.Column([ ft.Text("Texto\ndo\nAplicativo!")])],
            expand=True
        )
    )
ft.app(main)

O resultado da execução desse código está mostrado na figura 1.

Figura 1

Para fazer com que o NavigationRail apareça à direita vasta inverter a ordem de inserção dos objetos inseridos na linha ft.Row.

Propriedades de NavigationRail

Propriedade Descrição
bgcolor a cor do Container com o conteúdo do NavigationRail.
destinations define os itens de botão que são dispostos no NavigationRail. O valor é uma lista de 2 ou mais instâncias de NavigationRailDestination.
elevation o tamanho da sombra abaixo do NavigationRail. O default é 0.0.
extended Booleano com default False. Indica se NavigationRail deve ser estendido para ocupar o espaço disponível na página. No estado estendido o controle apresenta um padding lateral mais largo e os rótulos ficam ao lado dos ícones. Caso contrário esses rótulos ficam abaixo dos ícones e o container é mais estreito.

A propriadade min_extended_width é usada para definir a largura mínima do container quando estendido. No estado estendido deve-se definir label_typedeve=none.

group_alignment o alinhamento vertical para a lista de destinos dentro do container. Os controles filhos NavigationRailDestinations ficam dispostos entre os widgets postos em leading (no início da lista) e trailing (no fim da lista).

O valor deve ser um float entre -1.0 e 1.0. Os valores de group_alignment significam: -1,0: os itens serão alinhados na parte superior do espaço disponĩvel; 0.0 itens alinhados no centro; 1.0itens alinhados em baixo. Default= -1.0.

indicator_color cor dos indicadores do NavigationRail.
indicator_shape formato dos indicadores do NavigationRail. O valor é do tipo OutlinedBorder e o default é StadiumBorder().
label_type layout e o comportamento dos rótulos (labels) dentro do NavigationRail no estado default e não estendido. Os rótulos são sempre exibidos quando o controle está estendido.

O valor é do tipo NavigationRailLabelType e o default é None (nenhum rótulo é exibido).

leading um controle opcional colocado acima dos destinos no controle principal. Sua localização não é afetada por group_alignment.

O controle em leading geralmente é um FloatingActionButton, mas pode ser outro controle que não um botão, como uma imagem de um logotipo, por exemplo.

min_extended_width a largura final quando a animação estiver concluída quando se ajusta extended=True. O default é 256.
min_width a menor largura possível para o controle, independentemente dos tamanhos dos ícones ou rótulos dos destinos.

O default é 72. Este valor também define a largura mínima e a altura mínima dos destinos. Para criar um NavigationRailDestination compacto, defina min_width=56 junto com label_type=None.

selected_index índice selecionado na lista do NavigationRailDestination. Se selected_index=None nenhum destino é selecionado.
selected_label_text_style o estilo TextStyle do rótulo de um destino selecionado. Quando o destino não está selecionado o estilo em unselected_label_text_style será usado.
trailing Um controle opcional no NavigationRail, exibido abaixo dos destinos. Sua localização é afetada por group_alignment.

Pode ser usada uma lista de opções ou destinos adicionais que apenas é renderizada quando extended=True.

unselected_label_text_style o estilo TextStyle do rótulo de destino não selecionado. Quando o destino está selecionado o estilo em selected_label_text_style será usado.

Evento de NavigationRail

Evento Descrição
on_change dispara quando o destino selecionado é alterado.

NavigationRailDestination

Propriedades

Propriedades Descrição
icon ícone a exibir no destino.

# pode receber o ícone diretamente:
icon=ft.Icons.CHILD_FRIENDLY
# ou um controle flet.Icon
icon=ft.Icon(ft.Icons.CHILD_FRIENDLY)

Se selected_icon for fornecido, esse ícone só é exibido quando o destino não estiver selecionado.

icon_content idêntico à propriedade icon. Esse controle está obsoleto e será removido. Use icon.
indicator_color cor do indicator_shape (descrito abaixo) quando o destino é selecionado.
indicator_shape formato do indicador de seleção. O valor é uma instância da OutlinedBorderclasse.
label string mostrada no rótulo do destino. Só é exibida se label_content (descrito abaixo) não é fornecido.
label_content um controle usado como rótulo do destino. Se fornecido, label será ignorado.

O label deve ser fornecido no NavigationRail. Se for declarado NavigationRail.label_type=NavigationRailLabelType.NONE, o rótulo ainda é usado por questões semânticas e pode ser usado se NavigationRail.extended=True.

padding espaço interno para o item de destino. O valor é uma instância da classe Padding.
selected_icon nome do ícone ou controle alternativo exibido quando o destino é selecionado.

# usando o nome do ícone:
selected_icon=ft.Icons.BOOKMARK
# uso com controle:
selected_icon=ft.Icon(ft.Icons.BOOKMARK)

Se não for fornecido, o NavigationRail exibe icon em qualquer dos estados.

selected_icon_content ícone alternativo quando o destino é selecionado. Obsoleto, use selected_icon.

Nota: † Procure escolher ícones diferentes para estados diferentes, como ícones de traço e preenchidos para tornar o NavigationRail mais legível, como ft.Icons.CLOUD e ft.Icons.CLOUD_QUEUE. Ícones iniciais (icon) devem ser definidos para a versão com traço e selected_icon para a versão preenchida.

Exemplo de uso do NavigationRail

import flet as ft

def main(page: ft.Page):
    page.bgcolor=ft.Colors.GREY_400
    page.window.width=500
    page.window.height=400

    cidade=["Manaus", "Recife", "Olinda"]
    destinos=[
        ft.NavigationRailDestination(
            icon=ft.Icons.LOCATION_CITY,
            selected_icon=ft.Icons.AIRPLANE_TICKET,
            label=cidade[0],
        ),
        ft.NavigationRailDestination(
            icon=ft.Icon(ft.Icons.random()),
            selected_icon=ft.Icon(ft.Icons.AIRPLANE_TICKET_SHARP),
            label=cidade[1],
        ),
        ft.NavigationRailDestination(
            icon=ft.Icons.LOCATION_HISTORY_SHARP,
            selected_icon=ft.Icon(ft.Icons.AIRPLANE_TICKET_OUTLINED),
            label=cidade[2],
        ),
    ]

    def getBotao(i):
        return ft.FloatingActionButton(
            foreground_color=ft.Colors.YELLOW,
            bgcolor=ft.Colors.BLUE_300,
            icon=ft.Icons.NEW_LABEL if i==0 else ft.Icons.DELETE,
            on_click=nova_rota if i==0 else apagar,
            text="Nova Seleção" if i==0 else "Apagar Tudo",
        )

    def seleciona(e):
        texto_corpo.value+=f"\nDestino Selecionado: {cidade[e.control.selected_index]}"
        texto_corpo.update()

    def nova_rota(e):
        texto_corpo.value+=f"\n\nSelecione Nova Rota:\n{'-'*26}\n"
        texto_corpo.update()

    def apagar(e):
        texto_corpo.value=f"Selecione a sua rota:\n{'-'*26}\n"
        texto_corpo.update()

    rail = ft.NavigationRail(
        bgcolor=ft.Colors.BLUE,
        selected_index=0,
        label_type=ft.NavigationRailLabelType.ALL,
        min_width=180,
        min_extended_width=400,
        leading=getBotao(0),
        trailing=getBotao(1),
        group_alignment=0.0,
        destinations=destinos,
        on_change=seleciona,
        extended=False
    )

    texto_corpo=ft.Text(f"Selecione a sua rota:\n{'-'*26}\n", color=ft.Colors.INDIGO_900, size=16)
    espaco_direita=ft.Container(
        content=texto_corpo,
        padding = ft.padding.all(15),
        border=ft.border.all(3, ft.Colors.BLUE_600),
        alignment=ft.alignment.top_left,
        bgcolor=ft.Colors.GREY_50,
        expand=True
    )
    page.add(ft.Row([rail, ft.VerticalDivider(width=2), espaco_direita,], expand=True,))

ft.app(main)

O resultado da execução desse código está mostrado na figura 2.

Figura 2

Flet: Controles SafeArea e Placeholder

SafeArea


Outro controle voltado para a diagramação das páginas de aplicativos, SafeArea insere conteúdo com preenchimento (padding, as distâncias entre as margens internas do container com as bordas externas do controle) de modo a impedir que os elementos de interface do sistema operacional se sobreponham às do aplicativo. Ele recua o conteúdo interno evitando sobreposição pela barra de status no alto da tela.

Em particular esse recurso permite o recuo do conteúdo para evitar obstrução pelo “entalhe” no iPhone, (notch) ou outras modificações na geometria das telas em aparelhos menores. Quando um preenchimento mínimo é especificado, o maior preenchimento mínimo ou o preenchimento da área segura será aplicado.

Propriedades de SafeArea

Propriedade Descrição
bottom booleano, se o aplicativo deve evitar intrusão do sistema operacional na parte inferior da tela. Default é True.
content recebe o controle filho a ser exibido dentro SafeArea.
left booleano, se o aplicativo deve evitar intrusão do SO na parte esquerda da tela. Default é True.
maintain_bottom_view_padding booleano, default é False. Se True o controle SafeArea deve manter em exibição o MediaQueryData.viewPadding no parte inferior da tela, em vez do MediaQueryData.padding (que é o default).

Por exemplo, caso um teclado na tela seja exibido acima da SafeArea, o preenchimento interno (padding) pode ser mantido abaixo da obstrução sem ser ocultado. Pode ser útil quando o layout contém controles flexíveis que podem ser movidos na interface do usuário. Definir SafeArea=True evita alteração na IU.

minimum preenchimento (padding) mínimo a ser aplicado.
right booleano, se o aplicativo deve evitar intrusão do SO na parte direita da tela. Default é True.
right booleano, se o aplicativo deve evitar intrusão do SO na parte superior da tela, que em geral contém uma barra de status. Default é True.

Um exemplo de uso do controle pode ser visto em Uso de SafeArea.

Placeholder

A palavra “placeholder” pode ser descrita em português como “marcador de posição” ou “espaço reservado”. O controle placeholder desenha uma caixa na página, representando o local onde outro widget será colocado, mais tarde. Ele é útil para marcar áreas do aplicativo durante o desenvolvimento, para efeito de visualização e organização do projeto.

Basicamente o Placeholder pode inserido na página sem muitas propriedades.

import flet as ft
def main(page: ft.Page):
    page.add(ft.Placeholder(expand=True))
ft.app(main)

Propriedades de Placeholder

Propriedade Descrição
content um controle que pode ser adicionado dentro do placeholder (opcional)
color a cor do traço marcando o espaço reservado
fallback_height altura da caixa a ser usada quando o placeholder não tem uma altura definida. O valor é um float com default de 400.0.
fallback_width largura da caixa a ser usada quando o placeholder não tem uma largura definida. O valor é um float com default de 400.0.
stroke_width largura da linha usada para desenhar a caixa do placeholder na página. O value é um float com default de 2.0.

Exemplo de uso de Placeholder

import flet as ft

def main(page: ft.Page):
    page.title = "Página com um Placeholder"
    page.bgcolor=ft.Colors.BLUE_50
    page.window.width=500
    page.window.height=500
        
    page.add(
        ft.Container(
            border=ft.border.all(1, ft.Colors.BLACK),
            content=ft.Text("Um container com texto fora do placeholder", color=ft.Colors.BLACK),
            margin=ft.margin.symmetric(horizontal=1, vertical=1),
            alignment=ft.alignment.center,
            height=100,
            bgcolor=ft.Colors.GREEN_50,
        ),
        ft.Placeholder(
            expand=True,
            stroke_width=4.0,
            color=ft.Colors.DEEP_PURPLE_500,
            content=ft.Container(
                content=ft.Text("Um container com texto dentro do placeholder", color=ft.Colors.BLACK),
                alignment=ft.alignment.center,
                width=500,
                height=100,
            ),
            width=600,
        )
    )
ft.app(main)

Controle ReorderableListView

ReorderableListView

Um controle ReorderableListView é um widget container que admite controles filhos reposicionáveis. Ele cria uma lista similar à ListView com filhos que podem ser arrastados para novas posições, mostrando uma animação durante o movimento. Ele pode ser usado para abrigar listas com elementos de prioridade ajustável, como uma lista de tarefas ou de músicas.

Exemplo Básico

O controle ReorderableListView permite a construção de linhas ou colunas que podem ser arrastadas e reposicionadas, mudando de lugar com uma animação suave. No exemplo abaixo, dois desses controles são inseridos em uma página. No primeiro, declarado como uma lista horizontal (horizontal=True) são inseridos 2 elementos do tipo ft.Container. No segundo, uma lista vertical (horizontal=False, que é o default), são inseridos 2 elementos ft.ListTile.

import flet as ft

def main(page: ft.Page):
    page.add(        
        # 2 colunas dispostas horizontalmente
        ft.ReorderableListView(
            expand=True, horizontal=True,
            controls=[
                ft.Container(width=250, content=ft.Text("Festa"), alignment=ft.alignment.center, bgcolor="#228A82"),
                ft.Container(width=250, content=ft.Text("Trabalho"), alignment=ft.alignment.center, bgcolor="#8A4F22"),
            ],
        ),
        # 2 linhas dispostas verticalmente
        ft.ReorderableListView(
            controls=[
                ft.ListTile(title=ft.Text("Comprar cerveja"), bgcolor="#6C8785"),
                ft.ListTile(title=ft.Text("Tomar a cerveja"), bgcolor="#BA733C"),
            ],
        )
    )

ft.app(main)
Figura 1

O resultado desse código está mostrado na figura 1.

Os containers Festa e Trabalho podem ser movidos e realocados horizontalmente. Na parte inferior as linhas Comprar cerveja e Tomar cerveja podem ser arrastados verticalmentes e alterados em sua posição. Em um caso mais completo, os eventos de arrastar podem ser capturados (veja abaixo) para alterar propriedades do aplicativo, alterar um banco de dados ou executar qualquer outra ação desejada.

O arrasto é feito com o mouse nas marcas de abas (traços em azul). Se existirem mais controles que que o espaço disponĩvel para exibí-los, uma barra de rolagem é disponibilizada.

Observação: No atual estado do Flet (em Abril de 2025) a atualização de qualquer controle no aplicativo, como por exemplo, uma linha de texto informando sobre o estado da página, atualiza toda a página, retornando os controles ReorderableListView ao seu estado original.

Propriedades

O controle ReorderableListView possui as seguintes propriedades. Como ele pode conter diversos outros controles filhos a formatação e coleta de eventos dos filhos pode ser feita de forma independante.

Propriedade Descrição
anchor A posição relativa do deslocamento de rolagem zero. O default é 0,0.
auto_scroller_velocity_scalar A velocidade escalar por pixel sobre rolagem. Representa como a velocidade é dimensionada com a distância de rolagem. A velocidade de rolagem automática = (distância da overscroll) * velocidade escalar.
build_controls_on_demand Booleano. Se True controles são criados de forma preguiçosa/sob demanda, ou seja, somente quando se tornarem visíveis. Isso é útil quando de lida com um número grande de controles. O default é True.
cache_extent A janela de visualização (viewport) possui uma área antes e depois da área visível onde armazena em cache itens que serão tornados visíveis quando o usuário rola a página.

Itens nessa área de cache são dispostos antes de se tornarem visíveis na tela. O cache_extent define quantos pixels a área de cache inclui antes da borda inicial e depois da borda final da janela de visualização.

controls Lista de controles que serão inseridos e reordenados.
clipe_behavior O conteúdo será recortado (ou não) de acordo com esta opção. O valor é do tipo ClipBehavior e default é ClipBehavior.HARD_EDGE.
first_item_prototype Booleano. Se True as dimensões (largura e altura) definidas para o primeiro item são usadas como “protótipo” para os demais itens. O default é False.
footer Um controle a ser usado no rodapé. Esse item é não reordenável e será exibido ao final dos controles ordenáveis. O valor é do tipo Control.
header Um controle a ser usado como cabeçalho. Esse item é não reordenável e será exibido antes dos controles ordenáveis. O valor é do tipo Control.
horizontal Booleano, se os controles devem ser dispostos horizontalmente. O default é False.
item_extent Se não nulo, força os filhos a terem a extensão fornecida na direção de rolagem.

É mais eficiente especificar um item_extent do que deixar que os filhos determinem sua própria extensão pois o mecanismo de rolagem tem informação prévia da extensão dos filhos. Isso economiza trabalho, por exemplo, quando a posição de rolagem muda drasticamente.

padding Espaço de afastamento interno dos controles. O valor é do tipo Padding.

Eventos

O controle ReorderableListView responde aos seguintes eventos:

Evento Descrição
on_reorder Dispara quando um controle filho é arrastado para uma nova posicão. O aplicativo tem que ser atualizado para reordenar esses itens.
on_reorder_start Dispara quando o arrasto do controle filho é iniciado.
on_reorder_end Dispara quando termina o arrasto do controle filho.

O argumento de evento é do tipo OnReorderEvent, chamado e nos exemplos dados.

Exemplo de Uso do ReorderableListView

Um exemplo mais completo de uso do ReorderableListView está apresentado abaixo:

import flet as ft

def main(page: ft.Page):
    page.title = "Demonstração de ReorderableListView"
    page.bgcolor=ft.Colors.WHITE
    page.window.width=330
    page.window.height=620

    def move_coluna(e: ft.OnReorderEvent):
        print(f"Coluna movida da posição {e.old_index+1} para {e.new_index+1}.")

    def move_linha(e: ft.OnReorderEvent):
        print(f"Linha movida da posição {e.old_index+1} para {e.new_index+1}.")

    cor=[ft.Colors.GREEN_200, ft.Colors.GREEN_50, ft.Colors.GREEN_500, ft.Colors.GREEN]
    coluna=["A","B","C","D","E"]
    linha=["Comparar café","Tomar café","Comprar cerveja","Tomar cerveja","Dormir"]

    # Colunas dispostas horizontalmente
    lista_horizontal = ft.ReorderableListView(
        expand=True,
        horizontal=True,
        on_reorder=move_coluna,
        controls=[
            ft.Container(
                border=ft.border.all(1, ft.Colors.BLACK),
                content=ft.Text(f"{coluna[i]}", color=ft.Colors.BLACK),
                margin=ft.margin.symmetric(horizontal=1, vertical=5),
                width=60,                
                alignment=ft.alignment.center,
                bgcolor= cor[i%2],
            ) for i in range(5)
        ],
    )
    # linha_header
    linha_header=ft.Container(
        content=ft.Text("Coisas a Fazer", color=ft.Colors.WHITE),
        margin=ft.margin.symmetric(horizontal=0, vertical=5),
        padding=5,
        height=30,
        bgcolor= cor[2],
    )
    # linha_footer
    linha_footer=ft.Container(
        content=ft.Text("Fim da Página", color=ft.Colors.WHITE),
        margin=ft.margin.symmetric(horizontal=0, vertical=5),
        padding=5,
        height=30,
        bgcolor=cor[2],
    )

    # Linhas dispostas verticalmente
    lista_vertical=ft.ReorderableListView(
        expand=True,
        on_reorder=move_linha,
        header=linha_header,
        footer=linha_footer,
        controls=[
            ft.Container(
                border=ft.border.all(1, ft.Colors.BLACK),
                content=ft.Text(f"{linha[i]}", color=ft.Colors.BLACK),
                margin=ft.margin.symmetric(horizontal=1, vertical=1),
                width=330,
                height=40,
                padding=10,
                alignment=ft.alignment.center_left,
                bgcolor= cor[i%2],
            ) for i in range(5)
        ],
    )
    page.add(lista_horizontal, lista_vertical)

ft.app(main)

Após algumas operações de arrasto das linhas e colunas, as seguintes linhas são exibidas no console:

Linha movida da posição 1 para 4.
Linha movida da posição 2 para 3.
Coluna movida da posição 1 para 4.
Coluna movida da posição 2 para 3.

O resultado desse código está mostrado na figura 2 em seu estado inicial e depois dos arrastos descritos acima.

Observe que as propriedades controls de ambos os ReorderableListView, que são listas (lists ordinárias do Python), foram preenchidos com compressão de listas. Esse mecanismo está descrito em Compreensão de listas no Python e resumido abaixo:

$ lista1=[i** for i in range(10)]
$ print(lista1)
↳ [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

$ lista2=[i** for i in range(10) if i%2==0]
$ print(lista2)
↳ [0, 4, 16, 36, 64]

Portanto o código preenche a lista ft.ReorderableListView.controls com 5 instâncias de ft.Container, com i=0,...,4. As propriedades internas variam com i em linha[i], definida como uma lista no início do código, e cor[i%2], que pode ser apenas cor[0] ou cor[1], de outra lista já definida.

A propriedade horizontal=True define que os controles são dispostos na horizontal.

 

 

 

 



Regex, Consulta Rápida

Segue um resumo tipo cheat sheet para referência rápida sobre o uso de Expressões Regulares no Python.

Grupos de Caracteres

Padrão casa com
\w uma palavra comsposta de caracteres a-z, A-Z, 0-9 e sublinhado (_)
\d umúnico dígito 0-9
\s um espaço em branco incluindo \t, \n e \r
. qualquer caracter exceto quebra de linha
\W qualquer sinal exceto caracter alfanumérico e sublinhado
\D qualquer caracter exceto um dígito
\S qualquer caracter exceto um espaço em branco

Âncoras

Padrão significa
^ início de uma string
$ fim de uma string
\b posição definida como limite de palavra
\B posição definida como não sendo limite de palavra

Quantificadores

Na tabela abaixo chamamos de “quantificadores gulosos” ou greedy, aqueles que englobam a maior parte de texto possível casando o padrão. Já os “quantificadores não gulosos” ou lazy, englobam a menor parte de texto que satisfaz o padrão.

Quantificadores gulosos quantificadores não gulosos casa com
* *? o elemento precedente zero ou mais vezes
+ +? o elemento precedente uma ou mais vezes
? ?? o elemento precedente zero ou uma vez
{n} {n}? o elemento precedente exatamente n vezes
{n, } {n,}? o elemento precedente pelo menos n vezes
{n, m} {n, m}? o elemento precedente de n até m vezes

Conjunto e Faixas

Chamamos de faixas as ranges ou regiões delimitadas de um certo conjunto.

Padrão casa com
[XYZ] qualquer um dos elementos X, Y ou Z
[X-Y] elementos na faixa de X até Y
[^XYZ] qualquer elemento exceto X, Y ou Z
[^X-Y] qualquer elemento exceto aqueles na faixa de X até Y

Capturando Grupos

Padrão significa
(X) Captura X como um grupo
(?P<nome>X) Captura X e atribui a ele o nome
\N Referencia o grupo capturado #N
\g<N> sintaxe alternativa para referenciar o grupo capturado #N
X | Y casa X ou Y
(X) | (Y) casa o grupo (X) ou (Y)

Retrovisores

Em inglês se usa as expressões lookaround, lookbehind e lookafter para significar a busca por padrões dadas condições antes e depois do padrão regex. Chamaremos aui essas expressões de retrovisores.

Padrão significa
X(?=Y) casa com X se seguido por Y
X(?!Y) casa com X se não for imediatamente seguido por Y
(?<=Y)X casa com X se precedido por Y
(?<!Y)X casa com X se não precedido por Y

Funções Regex

São funções do módulo re:

re.fullmatch()retorna um objeto Match se o padrão casa com a string inteira

Método retorna
re.search(padrao, texto) 1º texto casado e sua posição, em qualquer parte do texto e em todas as linhas,
re.match(padrao, texto) 1º texto casado e sua posição, no início do texto e apenas na 1ª linha,
re.findall(padrao, texto) retorna uma lista com todos os trechos encontrados,
re.finditer() retorna um iterador com todos os trechos encontrados, não superpostos
re.split(padrao, texto) parte o texto na ocorrência do padrão e retorna as partes,
re.sub(padrao, sub, texto) substitue em texto o padrao por sub,
re.subn(padrao, texto) similar à sub mas retorna tupla com nova string e número de substituições
re.compile(padrao) compila e retorna um padrão regex pre-compilado

Flags ou sinalizadores Regex

Flag alias flag inline significado
re.ASCII re.A ?m essa flag só é relevante para padrões em bytes. Ele faz com que \w, \W,\b, \B, \d, \D e \S casem com ASCII caracteres apenas, ao invés do casamento com Unicode.
re.DEBUG N/A N/A a flag re.DEBUG provoca a exibição da informação de debug para o padrão compilado.
re.IGNORECASE re.I ?i faz busca independentemente do caso (maiúsculas/minúsculas). Portanto o padrão [A-Z] casa caracteres [a-Z] ou [a-z].
re.LOCALE re.L ?L só é relevante em padrões de bytes. Faz com que \w, \W, \b, \B e casamentos sensíveis ao caso dependente do locale do computador. Essa flag não é compatível com a flag re.ASCII flag.
re.MUTILINE re.M ?m essa flag faz com que as marcações ^/$ casem texto no início/final de cada linha em texto multi-linhas.
re.DOTALL re.S ?s essa flag faz com que o ponto (.) case todos as caracteres, inclusive newline. (Por default a marcação de ponto (.) casa qualquer caracter exceto newline).
re.VERBOSE re.X ?x essa flag permite que o padrão seja organizado em seções logicas, incluido a inserção de comentários.

Bibliografia

Gerenciador de pacotes Flatpak

O que é Flatpak

Flatpak é um utilitário (um aplicativo) usado para a distribuição, instalação e gerenciamento de pacotes de software no Linux. Ele usa um sistema de sandbox que permite aos usuários rodar aplicativos em um ambiente de isolamento partial do resto do sistema. Flatpak é também o nome de estrutura usada para criar pacotes de desktop em muitas distribuições Linux. Sua força está em sua abordagem para a entrega de software. Ele remove restrições tradicionais e fornece uma resposta simples para programas de computador, independentemente da linguagem de programação, do hardware ou das  das arquiteturas de softwares que eles usam. Essa flexibilidade garante que os construtores possam usar o flatpak sem questionar problemas de compatibilidade.

Muitos outros sistemas de gerenciamento de pacotes existem para os diversos sistemas operacionais. Para o Linux temos, por exemplo:

  • dpkg: usado pelo Debian, Ubuntu e seus derivados, distribuindo arquivos no formato .deb. Foi o primeiro a apresentar um mecanismo de resolução de dependências, usando o aplicativo APT do lado do usuário.
  • RPM: criado pela Red Hat, agora é usado por diversas distribuições como PCLinuxOS, Fedora, AlmaLinux, CentOS, openSUSE, OpenMandriva e Oracle Linux. RPM lida com pacotes .rpm, sendo a base de gerenciadores como apt4rpm, up2date (Red Hat), urpmi (Mageia), zypper (openSUSE), e dnf (Fedora, Red Hat e Yellow Dog Linux). Leia aqui as instruções de uso de DNF4 e DNF5.
  • Pacman: Usado no Arch Linux, Frugalware e DeLi Linux, é um formato de pacotes binários e comprimidos por tar. Os pacotes são gerenciados pelo utilitário makepkg.
  • Snap: um gerenciador desenvolvido pela CAnonical para o Ubuntu. Os pacotes, chamados snaps são gerenciados pela ferramenta snapd, usado por diversas distribuições. Como o flatpak também cria ambientes de isolamento dentro do sistema.
  • AppImage: não é propriamente um gerenciador de pacotes mas sim uma forma de distribuição de arquivos binários executáveis que podem ser redados em qualquer distibuição linux, sem a necessidade de ajusta para cada uma. As imagens em AppImages trazem contêm todas as dependências necessárias para a execução do aplicativo.

Conceitos básicos

Alguns conceitos são essenciais para a compreensão do flatpak. Ainda que existam aplicativos GUI para gerenciar os pacotes, é útil aprender os comandos na CLI (command line interface).

O que é Sandbox

sandbox é um mecanismo de segurança na computação, usado inicialmente no desenvolvimeto de softare para garantir que um código esteja logicamente isolado do sistema operacional do computador e outros aplicativos instalados. Ele contêm, em princípio, todas as dependências necessárias, embora existam sistemas em que parte dessas dependências pode ser encontrada no computador hospedeiro. Desta forma, é possível escolher exatamente as versões de cada dependência e outros recursos usados no desenvolvimento, evitando falhas e impedindo que vulnerabilidades se espalhem pelo sistema. O isolamento nas sandboxes significa que um processo externo a ela não pode interferir em um processo interno, e vice-versa.

Mais tarde, o mesmo conceito passou a ser usado para a própria instalação e execução de aplicativos nos computadores de usuários, criando ambientes isolados que restringem o seu acesso ao sistema operacional, limitando possíveis danos que um aplicativo malicioso ou com falhas de segurança pode causar. Essa é também uma forma de garantir que o aplicativo tenham acesso às dependências corretas e que a instalação de novos aplicativos não prejudiquem o sistema e os demais aplicativos instalados.

Cada aplicativo flatpak é criado e executado em seu próprio ambiente isolado (sandbox), que contém o aplicativo e todas as dependências necessárias para sua execução (runtime). Por default, o aplicativo só pode acessar a sua própria sandbox, embora seja possível dar permissões para seu acesso a arquivos de usuário, rede, soquetes gráficos e algns componentes do hardware. Alguns recursos, como outros processos em execução no host, são deliberadamente vedados. Em algumas situações alguns recursos dentro do sandbox precisam ser exportados para fora, para serem usados ​​pelo host. Esses recursos são denominados “exportações”, incluindo o arquivo de desktop do aplicativo com seu ícone.

Sandboxes, máquinas virtuais e conteineres: Uma máquina virtual é um ambiente virtualizado (isolado dentro do sistema operacional) que simula um sistema operacional completo. Por sua vez, um container isola um aplicativo e suas dependências em um ambiente virtualizado, compartilhando no entanto o kernel do sistema operacional hospedeiro. Os três conceitos são semelhantes, cada um com características próprias e propósitos específicos. Enquanto uma sandbox é mais genérica e pode ser usada para executar diversos tipos de programas de forma segura, uma máquina virtual simula um sistema operacional completo e é ideal para testes e desenvolvimento de software. Já um container é mais leve e ágil do que uma máquina virtual, sendo mais adequado para implementação e execução de aplicativos de forma isolada.

Repositório

Um repositório de software, ou repo, é um local de armazenamento para pacotes de software. Geralmente eles possuem uma lista de aplicativos disponibilizados, juntos com os seus metadados e runtime (as depedências). Repositório de software são gerenciado por controle de versão, e trabalham junto com gerenciadores de pacotes que permitem instalar e atualizar e gerenciar pacotes no computador do cliente.


Alguns dos repositórios de pacotes flatpak são:

  • Flathub: o maior e mais popular repositório.
  • GNOME Software: repositório oficial para o GNOME, com aplicativos projetados para o ambiente GNOME.
  • KDE Discover: repositório oficial para o KDE, com aplicativos otimizados para o ambiente KDE Plasma.
  • Elementary AppCenter: do Elementary OS.
  • Manjaro Community Repository: para a distribuição Manjaro Linux.

O principal repositório de pacotes flatpak atualmente (em dezembro de 2024) é o Flathub.

O Flathub fornece listas separadas para pacotas Trending, Popular, New, Updated e Verified. Aplicativos verificados no Flathub são aqueles mantidos diretamente pelo desenvolvedor ou algum grupo autorizado ou aprovado por ele. Aplicativos verificados aparecem com um ícone azul na página de seleção. Também existem aplicativos publicados no Flathub pela comunidade ou por terceiros, não mantidos pelo desenvolvedor original. Esses apps não são elegíveis para verificação.

Repositórios do flatpak se comportam de forma semelhante aos repositórios Git: um repositório flatpak pode conter um ou vários objetos, e cada um marcado com sua versão, permitindo atualizações ou downgrades. Cada sistema flatpak pode ser configurado para acessar um ou diversos repositórios remotos. Se um repositório é declarado em um sistema, torna-se possível acessar o conteúdo do repositório remoto, pesquisando a baixando dele aplicativos e runtimes. Em uma atualização, novas versões de aplicativos e runtimes são baixadas dos remotos relevantes. Como ocorre com o Git, apenas as partes alteradas entre as versões são baixadas, tornando o processo muito eficiente.

O manual do flatpak fornece instruções sobre como construir repositórios: Hosting a Repository.

Runtimes, bibliotecas empacotadas e portais

Runtimes: runtimes (ou ambiente de execução) são o conjunto das dependências básicas usadas pelos aplicativos. Todo aplicativo é criado no contexto de um runtime, que deve ser instalado no sistema host para que o aplicativo funcione adequadamente. O flatpak cuida da instalação do runtime necessário. Vários runtimes, com diferentes versões, podem ser instalados e usados lado a lado. Runtimes são independentes de distribuição e versão, fornecendo uma base estável para que os aplicativos funcionem independentemente das atualizações do sistema operacional.

Bibliotecas empacotadas, (bundled libraries): Se um aplicativo exige dependências não contidas em seu runtime, elas podem ser empacotadas junto com o aplicativo. Dessa forma os desenvolvedores têm flexibilidade na escolha de dependências, permitindo o uso de (a) bibliotecas não disponíveis em tempo de execução; (b) bibliotecas com versões diferentes das disponíveis no sistema; (c) versões corrigidas de bibliotecas.

Portais: portais são um mecanismo usados pelos aplicativos para interagir com o host, a partir de sua sandbox. Eles permitem o acesso a dados, arquivos e serviços sem necessitar de permissões adicionais. São exemplos de recursos acessados ​​por portais: abrir arquivos por meio de uma caixa de diálogo (seletor de arquivos) ou imprimir. Existem kits de ferramentas que oferecem suporte seguro e transparente para portais. Outras informações sobre portais podem ser encontradas em Permissões do Sandbox: Sandbox Permissions.

Flatpak, instalação e uso

Usamos aqui as seguintes convenções:
# linhas de comentários
$ linhas de código (input)
➡ linhas de saída (output)

Para instalar o flatpak em seu sistema, siga estas etapas:

# antes de instalar, atualize os pacotes do sistema atual
$ sudo apt update && upgrade      # no debian, ubuntu, etc 
$ sudo dnf update                 # no fedora

#  instale o Flatpak 
$ sudo apt install flatpak        # no debian, ubuntu, etc 
$ sudo dnf install flatpack       # no fedora
$ sudo zypper install flatpak     # no openSUSE
$ sudo pacman -S flatpak          # no arch linux
 
$ sudo apt install gnome-software-plugin-flatpak        # no debian, ubuntu, etc 
$ sudo dnf install gnome-software-plugin-flatpak        # no fedora

# para instalar os aplicativos precisamos adicionar o repositório remoto (flathub)
$ sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

# para verificar a instalação, podemos ver qual versão foi instalada
$ flatpak --version
➡ Flatpak 1.15.12

Para ver o procedimento de instalação para outras distros consulte Flathub Setup.

Se a instalação foi bem sucedida, podemos instalar pacotes flatpak. Instalações de aplicativos podem ser feitas apenas para o usuário (o app fica disponível apenas para aquele usuário) ou no sistema inteiro (o app fica disponível para todos os usuários do sistema). Abrimos o terminal e executamos:

# instalação global
$ flatpak install flathub com.jeffser.Alpaca
# após um pedido de confirmação a instalação é concluída

# para instalar apenas para o usuário (<remote> é o repositório, <name&gt nome do app)
$ flatpak install --user <remote> <name>
    
# se nenhuma mensagem de erro for emitida o aplicativo pode ser executado com
$ flatpak run <name>


Para encontrar o nome do aplicativo visitamos o repositório de pacotes no Flathub, onde uma lista de aplicativos será exibida. Digamos, por exemplo, que queremos instalar o Alpaca, um gerenciador de servidores de Inteligências Artificiais. Pesquisamos Alpaca e encontramos:

  • Comando para instalação: flatpak install flathub com.jeffser.Alpaca
  • Comando para executar o app: flatpak run com.jeffser.Alpaca

Portanto executamos o código:

# instalação global
$ flatpak install flathub com.jeffser.Alpaca

# para instalar apenas para o usuário logado
$ flatpak install --user flathub com.jeffser.Alpaca

Para evitar as perguntas de confirmação, respondendo yes (sim) para todas as perguntas, use o parâmetro -y:

$ flatpak install flathub com.jeffser.Alpaca -y

É possível, dependendo do sistema, que apenas o primeiro passo da instalação seja necessário e o aplicativo fique integrado ao sistema. Nesse caso basta abrir o menu utilizado e clicar em seu ícone.

Nota: se você tem diversos aplicativos para instalar, e o faz regularmente, para reinstalar e atualizar o sistema operacional, você pode armazenar um artigo de texto contendo os comandos de instalações, separados por &&. Para reinstalá-los basta copiar o texto e colá-lo no terminal. (A maioria dos terminais Linux recebem colagem da área de transfrência com CTRL-SHIFT-V.)

Por exemplo, para instalar o WPSOffice, Geany e Zed, cole no terminal:

flatpak install flathub com.wps.Office -y && 
flatpak install flathub org.geany.Geany -y &&
flatpak install flathub dev.zed.Zed -y

Desinstalação de pacotes:

Uma vez instalado um aplicativo, ele pode ser desinstalado (removido do sistema) com o seguinte comando:

$ sudo flatpak uninstall <nome do pacote/aplicativo>

# por exemplo, para desinstalar o alpaca
$ flatpak uninstall com.jeffser.Alpaca -y

# podemos usar o alias remove
$ flatpak remove <nome do pacote/aplicativo>

Nota: Na desinstalação deve-se usar o mesmo nome com que o aplicativo foi instalado.

Atualizando ou rebaixando a versão de pacotes

O flatpak fornece funcionalidade de atualização de aplicativos instalados através do seguinte comando:

# atualizar    
$ sudo flatpak update <nome do pacote/aplicativo>

# ex.: para atualizar o alpaca
$ sudo flatpak update com.jeffser.Alpaca

# para atualizar aplicativo instalado para o usuário apenas
$ flatpak update --user com.jeffser.Alpaca

Também é possível rebaixar a versão instalada de algum aplicativo. Suponha, por exemplo, que necessitamos de uma versão anterior do navegador Brave. Primeiro pesquisamos no repositório informações sobre o navegador, com remote-info --log flathub, onde podemos encontrar versões anteriores disponíveis.

# para ver informações sobre o Brave    
$ flatpak remote-info --log flathub com.brave.Browser
➡ Brave - Fast Internet, AI, Adblock
        ID: com.brave.Browser
       Ref: app/com.brave.Browser/x86_64/stable
      Arch: x86_64
    Branch: stable
   Version: 1.73.101
   [truncado]
 
    Commit: 852620f9b5998b4cbfd621cf523e4367ba80b517427c810b8166eb48aa9f50db
   Subject: version update (7d8acf2a)
      Date: 2024-11-20 17:56:11 +0000
  [truncado]

# escolhemos a versão update (7d8acf2a) e anotamos o código de commit
# fazemos o update para aquele commit  
$ sudo flatpak update \
      --852620f9b5998b4cbfd621cf523e4367ba80b517427c810b8166eb48aa9f50db \
      com.brave.Browser

Gerenciando repositórios

Para adicionar um repositório no flatpak usamos:

# adicionar repositório
$ sudo flatpak remote-add --if-not-exists [name] [location]

# ex: adicionar o repositório do FlatHub repository
$ sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

# depois de instalado podemos procurar um pacote no repo
# procurando o gimp
$ flatpak search gimp
➡ Name                   Description            Application ID                Version     Branch           Remotes
  GIMP User Manual       GIMP User Manual       org.gimp.GIMP.Manual           2.10        2.10            flathub
  GNU Image Manip…       Create images and...   org.gimp.GIMP                  3.0.0~rc1   stable          fedora,flathub
  GimpLensfun            Lensfun Gimp plugin    org.gimp.GIMP.Plugin.Lensfun   0.2.4       2-40            flathub
  Fourier                Fourier GIMP Plugin    org.gimp.GIMP.Plugin.Fourier   0.4.5       2-40            flathub
  [lista truncada]

# para instalar o GIMP do repo Flathub
$ sudo flatpak install flathub org.gimp.GIMP

Se existirem mais de um repositório adicionados as várias opções disponíveis serão exibidas, como mostrado no exemplo acima. Você pode escolher qual pacote instalar, e de qual repositório. No caso foi instalado o org.gimp.GIMP, obtido no repositório flathub. Se não houver ambiguidade o nome do reposiório pode ser omitido.

Podemos listar quais são os repositórios cadastrados localmente com o flatpak. Para isso usamos remote-list. Para remover um desses repositórios da lista usamos remote-delete:

# listar repos cadastrados (existem apenas 2)
$ flatpak remote-list
➡ Name    Options
  fedora  system,oci
  flathub system

# podemos remover um repo
$ flatpak remote-delete flatub

Se existirem aplicativos ou runtimes instalados à partir desse repositório, surgirá a opção de remover ou não esses apps. Para remover apenas o repositório, deixando os aplicativos inalterados, usamos:

$ flatpak remote-delete --force <nome-repositorio>

Permissões e Sandboxing

Por default os aplicativos Flathub podem ser instalados com permissões mais amplas que as exigida no sistema ou desejadas pelo usuário, para que um número maior de usuários sejam atendidos por essa instalação. Como exemplo, o Brave tem instalação default com –socket=pcsc (entre outras) para acesso por cartão inteligente. Se o usuário não tem um desses cartões ele pode desejar modificar as permissões para melhorar a segurança.

# para mostrar as permissões
$ flatpak info --show-permissions com.brave.Browser
➡ [Context]
   shared=network;ipc;
   sockets=x11;wayland;pulseaudio;pcsc;cups;
   devices=all;
   [truncado]

# alterar a permissão
$ flatpak override --user --nosocket=pcsc com.brave.Browser

# verifica o estado
$ flatpak override --user --show com.brave.Browser
➡ [Context]
  sockets=!pcsc;

# para ressetar todas as alterações
$ flatpak override --user --reset com.brave.Browser

Existem várias ferramentas GUI disponíveis, como Flatseal, GNOME Settings e KDE Settings, que permitem alterar essas permissões em um ambiente de janelas.

Aplicativos instalados e histórico de operações

Para listar os aplicativos e runtimes instalados com flatpack usamos flatpak list. Para listar apenas os aplicativos instalados, flatpak list --app e apenas os ambientes, flatpak list --runtime.

# lista de aplicativos e runtimes
$ flatpak list
➡ Name             Application ID                        Version
  Bitwarden        com.bitwarden.desktop                 2024.12.0
  Mesa             org.freedesktop.Platform.GL.default   21.3.9
  Brave            com.brave.Browser                     1.73.101
  Alpaca           com.jeffser.Alpaca                    2.9.0
  ZapZap           com.rtosta.zapzap                     5.3.9
  Sigil            com.sigil_ebook.Sigil                 2.2.0
  Zed              dev.zed.Zed                           v0.165.4
  Obsidian         md.obsidian.Obsidian                  1.7.7
  SiYuan           org.b3log.siyuan                      3.1.15
[a lista está truncada]

# lista apenas de aplicativos
$ flatpak list --app
➡ Name            Application ID               Version
  Bitwarden       com.bitwarden.desktop        2024.12.0
  Brave           com.brave.Browser            1.73.101
[a lista está truncada]

# lista apenas de runtimes
$ flatpak list --runtime
➡ Name                       Application ID                       Version
  Codecs                     org.audacityteam.Audacity.Codecs      stable
  Mesa                       org.freedesktop.Platform.GL.default   21.3.9
  GNOME App Platform v. 47   org.gnome.Platform                    47                  
[a lista está truncada]

Além das colunas mostradas ainda temos informações sobre Branch, Origin, Installation, não exibidas.

Para obter um histórico de operações realizadas com flatpak usamos:

$ flatpak history
➡ Time               Change           Application                           Branch      Installation     Remote
   Dec 13 11:08:56   add remote                                                          system          fedora
   Dec 13 11:08:56   add remote                                                          system          fedora-testing
   Dec 13 11:10:42   add remote                                                          system          flathub
   Dec 13 11:57:21   deploy install   org.freedesktop.Platform.GL.default    23.08       system          flathub
   Dec 13 11:57:24   deploy install   org.freedesktop.Platform.GL.default    23.08-extra system          flathub
   Dec 13 11:57:24   deploy install   org.freedesktop.Platform.Locale        23.08       system          flathub
[a lista está truncada]

Para renovar e reparar o sistema de referências a repositórios do flatpak, usamos
. A remoção de extensões e runtimes não usados por qualquer um dos aplicativos instalados, usamos uninstall --unused.

$ sudo flatpak repair 
➡ Working on the system installation at /var/lib/flatpak
  [175/175] Verifying flathub:runtime/com.bitwarden.desktop.Locale/x86_64/stable… # os aplicativos e runtimes são verificados
  Checking remotes...
  
# para eliminar 
$ flatpak uninstall --unused
➡ Nothing unused to uninstall  


A reparação de uma instalação do flatpak faz uma verificação geral das referências disponíveis localmente, removendo aquelas que não correspondem a pacotes instalados. Ela também remove as referências a objetos inválidos e aqueles que não estão referenciados por nenhum aplicativo. Finalmente ela enumera as referências instaladas e reinstala aquelas que não estão completas.

Informações sobre pacotes instalados podem ser vistas com:

$ flatpak info com.jeffser.Alpaca
➡ Alpaca - Chat with local AI models
          ID: com.jeffser.Alpaca
         Ref: app/com.jeffser.Alpaca/x86_64/stable
        Arch: x86_64
      Branch: stable
     Version: 2.9.0
     License: GPL-3.0-or-later
  [saída truncada]

Executando e pesquisando

flatpak run <aplicativo> executa (roda) o <aplicativo>.
Por exemplo, vimos no output de flatpak list que o nome identificador (id) do navegador Brave é com.brave.Browser. Portanto podemos rodar o aplicativo usando o comando:

# para executar o aplicativo do Brave    
$ flatpak run com.brave.Browser
➡ Gtk-Message: 19:18:19.612: Failed to load module "canberra-gtk-module"
# possíveis mensagens de erro, como a mostrada acima, são listadas no console

# uma lista de aplicativos em execução é exibida com ps
$ flatpak ps
➡ Instance   PID   Application       Runtime
  3817365666 3283  org.geany.Geany   org.freedesktop.Sdk
  846534418  16554 com.brave.Browser org.freedesktop.Platform
  1876930084 16599 com.brave.Browser org.freedesktop.Platform

# para fechar um aplicativo usamos kill 
$ flatpak kill com.brave.Browser
# o Brave (duas instâncias) é fechado

Utilitários GUI

Algumas das funções de gerenciamento de pacotes podem ser executadas através de aplicativos com interface gráfica. Atualmente no repositório Flathub encontramos, por exemplo:

Easy Flatpak: uma loja de aplicativos flatpak, que auxilia na instalação de aplicativos de uma forma amigável, apenas clicando nos botões. Em alguns casos existem receitas para aperfeiçoar algumas instalações, como no caso do Steam, que permite ao usuário escolher o diretório de armazenamento dos jogos.

Flatseal: um utilitário gráfico que permite a visualização e edição das permissões de aplicativos flatpak.

Flatsweep: permite a remoção de arquivos e dependência eventualmente deixados na remoção de um pacote.

Warehouse: fornece uma IU simples para controlar opções complexas do flatpak, sem recorrer à linha de comando. Com ele é possível:

  • gerenciar Flatpaks instalados e visualizare propriedades dos pacotes,
  • alterar versões de um Flatpak e reverter atualizações indesejadas,
  • fixar os runtimes e mascarar Flatpaks (para evitar atualizações),
  • filtrar pacotes e classificar dados para tornar as buscas mais eficientes,
  • consultar dados atuais do usuário do aplicativo, limpando dados desnecessários,
  • adicionas repositórios do Flatpak,
  • fazer instantâneos (snapshots) de dados do usuário e aplicativos para backup,
  • instalar pacotes de qualquer repositório remoto ou pacotes baixados.

Resumo dos comandos

Uso: flatpak [OPTION…] COMMAND

Opção de ajuda: flatpak -h ou flatpak --help exibe a lista de comandos do flatpak.

Comandos internos (Built in): gerencia aplicativos e runtimes instalados

install Instala aplicativo ou runtimes
update Atualiza um aplicativo ou runtime instalados
uninstall Desinstala um aplicativo ou runtimes
mask Aplica máscara para excluir atualizações e instalações automáticas
pin Trava um runtime para impedir a remoção automática
list Lista aplicativos e/ou runtimes instalados
info Mostra informações sobre aplicativos ou runtimes instalados
history Lista o histórico
config Configura o flatpak
repair Repara a instalação do flatpak
create-usb Coloca aplicativos ou runtimes em mídia removível

Busca de aplicativos e runtimes

run Executa um aplicativo
override Sobreescreve as permissões de um aplicativo
make-current Especifica qual a versão padrão a ser executada
enter Insire o namespace de um aplicativo em execução
ps Lista os aplicativos em execução
kill Interrompe a execução de um aplicativo

Gerencia o acesso a arquivos:

documents Lista arquivos exportados
document-export Concede a um aplicativo acesso a um arquivo específico
document-unexport Revoga acesso a um arquivo específico
document-info Mostra informações sobre um arquivo específico

Gerencia permissões dinâmicas

permissions Lista permissões
permission-remove Remove item do armazenamento de permissões
permission-set Define permissões
permission-show Mostra permissões do aplicativo
permission-reset Redefine permissões do aplicativo

Gerencia repositórios remotos

remotes Lista todos os repositórios remotos configurados
remote-add Adiciona um novo repositório remoto (por URL)
remote-modify Modifica propriedades de um repo remoto configurado
remote-delete Excluir um repo remoto configurado
remote-ls Lista o conteúdo de um repositórioa configurado
remote-info Exibe informações sobre aplicativo remoto ou runtime

Construção de aplicativos

build-init Inicializa um diretório para construção
build Executa um comando dentro do diretório de construção
build-finish Conclui um diretório de construção para exportação
build-export Exporta diretório de construção para um repositório
build-bundle Cria um arquivo de pacote usando referência a repositório local
build-import-bundle Importa um arquivo de pacote
build-sign Assina um aplicativo ou runtime
build-update-repo Atualiza o arquivo de resumo de um repositório
build-commit-from Cria novo commit com base na referência existente
repo Exibe informações sobre um repositório

Opções do aplicativo:

–version Imprime informações sobre a versão e termina
–default-arch Imprime a arquitetura padrão e termina
–supported-arches Imprime as arquiteturas suportadas e termina
–gl-drivers Imprime os drivers gl ativos e termina
–installations Imprime caminhos para instalações do sistema e termina
–print-updated-env Imprime o runtime atualizado necessário para execução de flatpaks
–print-system-only Inclui apenas a instalação do sistema com –print-updated-env
-v, –verbose Mostra informações de depuração, -vv para mais detalhes
–ostree-verbose Mostra informações de depuração do OSTree

Nota †: No contexto do flatpak, runtime, também chamado de platforma, é o ambiente integrado básico de utilitários que permite a execução de um aplicativo flatpak.

Bibliografia

DNF5: Gerenciador de Pacotes

DNF4 para DNF5

Já vimos nessas notas o funcionamento do DNF, gerenciador de pacotes de software no linux. Nessa ocasião o comando dnf se referia (era um aliás) para dnf4. O Fedora mudou do DNF4 para o DNF5 devido à necessidade de atualizar e melhorar o gerenciador de pacotes do sistema operacional. O DNF5 foi construído pelo esforço coletivo das equipes do Fedora e do Red Hat, e traz várias vantagens em relação à versão anterior, incluindo melhor desempenho, maior estabilidade, correções de bugs e melhorias na interface do usuário. Além disso, o DNF5 oferece suporte a novas funcionalidades e melhor integração com outros componentes do sistema operacional. O DNF5 está instalado no Fedora desde a versão 38, não sendo o gerenciador de pacotes padrão, por default. No Fedora 41 ele é instalado como padrão, e recebe o álias dnf. A versão anterior está ainda disponível, bastando digitar dnf4 na linha de comando. Uma página da documentação descreve as alterações entre dnf4 para dnf5, em Changes between DNF4 and DNF5.

O que é um gerenciador de pacotes?

Um gerenciador de pacotes é um conjunto de aplicativos usados para automatizar o processo de instalação, atualização, configuração e remoção de programas de computador de uma maneira consistente. Ele manipula pacotes, que são distribuições de software e dados, contendo metadados como o nome do software, descrição de propósito, versão, fornecedor, checksum e uma lista de dependências necessárias. Na instalação, os metadados são armazenados em um banco de dados local. Gerenciadores de pacotes usam esse banco de dados de dependências para evitar incompatibilidades de software e pré-requisitos ausentes. Eles trabalham em conjunto com os repositórios de software, algumas vezes acessados pelas lojas de aplicativos. Diversas distribuições Linus usam DNF (ou YUM), entre elas: RedHat Enterprise Linux, Fedora, CentOS, Oracle Enterprise Linux, SUSE, OpenSUSE, Mageia e Turbolinux.

Nessas notas descreveremos o aplicativo DNF5 sem fazer alusão alusão ao artigo anterior, para que ele possa ser lido independentemente.

Usamos aqui as seguintes convenções:
# linhas de comentários
$ linhas de código (input)
➡ linhas de saída (output)

O que é RPM?

O RPM Package Manager (RPM) é um sistema de gerenciamento de pacotes de código aberto. Os arquivos que ele empacota recebem a extensão .rpm. O gerente RPM foi criado para uso no Red Hat Linux, mas agora é usado em muitas distribuições Linux, como PCLinuxOS, Fedora Linux, AlmaLinux, CentOS, openSUSE, OpenMandriva e Oracle Linux.

Um pacote RPM pode conter um número variado de arquivos. A maioria deles são “RPMs binários” (ou BRPMs), que contém a versão já compilada de algum software. Também existem “RPMs de origem” (ou SRPMs) que trazem o código-fonte usado para construir um pacote binário. Nesse caso eles têm uma tag no cabeçalho do arquivo que os marca como SRPM e faz com que esses arquivos sejam extraídos para /usr/src na instalação.

Repositórios: RPMs são frequentemente coletados em um ou mais repositórios na internet, chamados repositórios. Alguns sites replicam esses repositórios, nos espelhos locais (ou mirrors). Aplicativos destinados a faciltar o uso desses arquivos, gerenciando instalações, dependências e conflitos são os front ends. Alguns exemplos são: YUM (a base para o dnf); DNF; up2date; Zypper, urpmi, apt-rpm, uma adaptação para usar pacotes rpm no Debian, entre outros.

Banco de dados de instalação local: o gerenciador de pacotes usa uma banco de dados (rpmdb), armazenado em /var/lib/rpm. Diversos gerenciadores podem ser usados, como o SQLite ou Berkeley DB, contendo todas as meta informações dos pacotes instalados. É possível identificar qual o gerenciador está sendo usado com o comando rpm --showrc. Esse banco de dados indexa a informção para acelerar as consultas, e mantém o controle de todos os arquivos alterados e criados pelo usuário, permitindo a reversão das alterações e remoção de pacotes. Em caso de corrupção desse banco de dados de índice, eles podem ser recriados com o comando rpm --rebuilddb.

# para descobrir o dbms usado pelo rpm
$ rpm --showrc

# para restaurar banco de dados corrompido
$ rpm --rebuilddb

O que é DNF5?

O DNF5 é um gerenciador de pacotes que automatiza o processo de instalação, atualização, configuração e remoção de programas de computador de forma consistente. Ele suporta pacotes RPM, módulos modulemd e grupos e ambientes comps. libdnf é a biblioteca de gerenciamento de pacotes, escrita originalmente para suportar o gerenciador de pacotes DNF, mas gradualmente cresceu e se tornou uma biblioteca versátil. Agora é possível usar libdnf para construir ferramentas personalizadas que carregam repositórios, resolvem dependências, consultam e instalam pacotes. O DNF5 também é alimentado pela biblioteca libsolv, que fornece uma interface de programação fácil de usar.

O DNF5 você pode trabalhar com os seguintes artefatos:

  • Repositórios e pacotes RPM: descritos acima.
  • Módulos modulemd: modulemd é um arquivo que define quais pacotes são construídos para cada versão do sistema operacional. Ele inclui um resumo e uma descrição, uma lista de pacotes RPM de origem, informações sobre a ordem em que os aplicativos são instalados, junto com macros e informações de uso, ou seja, perfis de instalação e licenças.
  • Ambientes e grupos comps, Metadados de composição da distribuição (Distribution Compose Metadata): Objetos comps reune informações sobre todos os repositórios disponíveis.
  • Avisos (updateinfo, erros): Avisos são mensagens informativas que não impedem a conclusão do comando DNF mas indicam problemas potenciais e sugerem alternativas. Updateinfo é um metadado com informações sobre atualizações disponíveis para pacotes. Quando o DNF encontra updateinfo, ele pode exibir informações sobre atualizações disponíveis, incluindo o nome do pacote, versão e repositório. Updateinfo não é um erro, mas sim uma notificação sobre atualizações disponíveis. Erros são mensagens críticas que impedem a conclusão do comando DNF. Eles podem informar da ausência de dependências, erros no repositório, etc.

Instalação

Para instalar o gerenciador de pacotes DNF5, use um dos seguintes comandos, dependendo da sua versão do Fedora. Verifique antes se ele já não está instalado.

# no Fedora 37 ou outro sistema sem a instalação do repositório
$ sudo dnf copr enable rpmsoftwaremanagement/dnf-nightly 
# instalando 
$ sudo dnf install dnf5

# no Fedora 38+ o repositório já está incluído
$ sudo dnf install dnf5
	
# verifique qual versão instalada, e em que diretório.
$ which dnf5
➡ /usr/bin/dnf5
 
# ou 
$ dnf5 --version
➡ dnf5 version 5.2.7.0
  dnf5 plugin API version 2.0
  libdnf5 version 5.2.7.0
  libdnf5 plugin API version 2.0
 [truncado]

Os seguintes comandos são de uso frequente com o dnf (usado como álias para o dnf5):

Comandos:

Comando, aliás Descrição
$ dnf upgrade <pacote> Atualiza o sistema e pacotes para a versão mais recente.
$ dnf search <pacote> Pesquisa pacotes disponíveis no repositório do sistema.
$ dnf install <pacote> Instala um nova pacote especificado pelo nome.
$ dnf remove <pacote> Remove pacotes instalados especificaods pelo nome.
$ dnf distro-sync <pacote> Sincronize os pacotes instalados com as versões mais recente disponíveis nos repositórios para a versão atual do Fedora.
$ dnf repoquery <pacote> Pesquisa a informação sobre o pacote especificado nos repositórios DNF.
$ dnf list <pacote> Exibe informações sobre pacotes que se ajustem à especificação.
$ dnf info <pacote> Coleta informação detalhada sobre o pacote especificado.
$ dnf makecache Refaz e atualiza o cache de metadata do gerente de pacotes DNF.
$ dnf repolist Exibe a lista de repositórios junto com informações sobre o número de pacotes disponíveis em cada repositório.
$ dnf repoinfo Exibe informação sobre os repositórios configurados no sistema.

As páginas do manual do aplicativo podem ser visualizados com man dnf, para ajuda geral, ou man dnf list para a ajuda sobre o parâmetro específico list ou outro qualquer.

Exemplos de uso do dnf

Alguns exemplos podem ajudar a compreender o uso do dnf. Observe que algumas operações exigem o uso do sudo.
O comando sudo (Super User DO) é usado como um prefixo para comandos que só podem ser executados por superusuários, aqueles que têm permissão. Isso faz com que o comando após o sudo seja executado com privilégios elevados. Vários usuários podem ter acesso ao sudo, desde que estejam declarados como administradores no arquivo sudoers em /etc/sudoers. Por padrão, esses usuários executam funções administrativas usando as suas próprias senhas.

upgrade, search, install, remove

No exemplo abaixo lidamos com a pesquisa, instalação e remoção do aplicativo featherpad, um editor de texto puro usando Qt.

Exemplos de uso:

# fazer a atualização do pacote featherpad
$ sudo dnf upgrade featherpad
➡ Updating and loading repositories:
  Repositories loaded.

# pesquisar pelo pacote nos repositórios cadastrados 
$ dnf search featherpad
➡ Updating and loading repositories:
  Repositories loaded.
  Matched fields: name (exact)
  featherpad.x86_64: Lightweight Qt Plain-Text Editor

# instalar a pacote, que deve estar nos repositórios cadastrados 
$ sudo dnf install featherpad
➡ Updating and loading repositories:
  Repositories loaded.
  Package                   Arch           Version         Repository         Size
  Installing:
featherpad              x86_64         1.5.1-1.fc41    fedora             3.4 MiB

  Transaction Summary:
   Installing:         1 package

  Total size of inbound packages is 893 KiB. Need to download 893 KiB.
  After this operation, 3 MiB extra will be used (install 3 MiB, remove 0 B).
  Is this ok [y/N]: y
# featherpad-0:1.5.1-1.fc41.x86_64 é instalado e pode ser usado
$ featherpad
                                                                                                                                  
# desinstalar o aplicativo featherpad
$ sudo dnf remove featherpad
➡ Package            Arch          Version         Repository            Size
  Removing:
   featherpad      x86_64           1.5.1-1.fc41   fedora                  3.4 MiB
  Transaction Summary:
Removing:  1 package
  Is this ok [y/N]: y
# o featherpad é removido do sistema

# para evitar que a execução seja interrompida por perguntas use
$ sudo dnf install featherpad -y
$ sudo dnf remove featherpad -y

Os comandos de instalação e remoção perguntam ao usuário: Is this ok [y/N]: , sendo que a resposta “Não” é o default. Para responder Yes para todas as perguntas use a chave -y (ou -n para responder No).

makecache, repolist, repoinfo

Também podemos gerenciar, inserindo ou removendo os repositórios cadastrados de acordo com as necessidades.

# para listar os repositórios cadastrados
$ dnf makecache
➡ Updating and loading repositories:
  Repositories loaded.
  Metadata cache created.
  
# para listar os repositórios cadastrados
$ dnf repolist
➡ repo id                                                            repo name
  copr:copr.fedorainfracloud.org:ryanabx:cosmic-epoch                 Copr repo for cosmic-epoch owned by ryanabx
  copr:copr.fedorainfracloud.org:wiiznokes:cosmic-applets-unofficial  Copr repo for cosmic-applets-unofficial owned by wiiznokes
  fedora                                                              Fedora 41 - x86_64
  fedora-cisco-openh264                                               Fedora 41 openh264 (From Cisco) - x86_64
  rpmfusion-free                                                      RPM Fusion for Fedora 41 - Free
  rpmfusion-free-updates                                              RPM Fusion for Fedora 41 - Free - Updates
  rpmfusion-nonfree                                                   RPM Fusion for Fedora 41 - Nonfree
  rpmfusion-nonfree-updates                                           RPM Fusion for Fedora 41 - Nonfree - Updates
  updates                                                             Fedora 41 - x86_64 - Updates

# para listar as propriedades dos repositórios
$ dnf repoinfo
➡ Updating and loading repositories:
  Repositories loaded.
  Repo ID             : copr:copr.fedorainfracloud.org:ryanabx:cosmic-epoch
  Name                : Copr repo for cosmic-epoch owned by ryanabx
  Status              : enabled
  Priority            : 99
  Cost                : 1000
  Type                : available
  Metadata expire     : 172800 seconds (last: 2024-11-15 14:08:04)
  Skip if unavailable : true
  Config file         : /etc/yum.repos.d/_copr:copr.fedorainfracloud.org:ryanabx:cosmic-epoch.repo
  URLs                :
Base URL          : https://download.copr.fedorainfracloud.org/results/ryanabx/cosmic-epoch/fedora-41-x86_64/
  PGP                 :
Keys              : https://download.copr.fedorainfracloud.org/results/ryanabx/cosmic-epoch/pubkey.gpg
Verify repodata   : false
Verify packages   : true
  Repodata info       :
   Available packages : 626
Total packages    : 626
Size              : 22.9 GiB
Revision          : 1731404232
Updated           : 2024-11-12 09:37:12
# [truncado] segue as descrições dos demais repositórios registardos no computador

O comando dnf makecache é usado para baixar metadados para os repositórios habilitados, atualizando os dados locais. Ele tenta evitar o download de novos dados sempre que possível, por exemplo, quando os dados locais ainda não expiraram ou quando o carimbo de data/hora não foram alterados.

repolist é um aliás para repo list (ou seja, list é um parâmetro do comando repo), usado para listar os repositórios cadastrados. Se nenhum repositório estiver configurado ele não apresenta nenhum retorno. Da mesma forma repoinfo é um aliás para repo info, listando repositórios e suas propriedades.

Glossário

Especificação de padrões

Globs: globs são padrões que especificam um comjunto de nomes de arquivos usando caracteres “curingas” ou wildcard. Os padrões aceitos pelo dnf são os mesmos usados pela shell. Os seguintes padrões podem ser usados.

Definições:

* casa com qualquer número de caracteres, ou vazio.
? casa com um caracter único.
[xyz] casa com x, y ou z; qualquer um dos caracteres entre colchetes.
[a-z] casa qualquer um dos caracteres entre a até z, inclusive.
[!a-z] ou [^a-z] não casa com nenhum dos caracteres na faixa de a até z.
{ } colchetes não são suportados.

Exemplos:

*.txt casa com qualquer nome de arquivo que termina com .txt, como “texto.txt”, “aa.txt” ou “.txt”.
su*.css casa com “su.css”, “superman.css” ou “sucata.css”.
?asa.toml casa com qualquer nome de arquivo como “casa.toml”, “rasa.toml” ou “sasa.toml”.
??uga.pdf casa com “aluga.pdf”, “_ruga.pdf” mas não casa com “beluga.pdf”.
[a-m]luga.hlmt casa com “aluga.hlmt”, “gluga.hlmt”, “kluga.hlmt”, mas não com “pluga.hlmt”.
[!1-5]fix.jpg não casa com “3fix.jpg” nem “5fix.jpg”, mas casa com “7fix.jpg”.
[^1-5]fix.jpg o mesmo que acima.

Padrão NEVRA

Pacotes podem ser identificados exclusivamente pela string NEVRA, que consiste de 5 partes de informação:
Name | Epoch | Version | Release | Architecture

São eles: name do pacote (pode conter hifens), Epoch, um número, timestamp, nem sempre incluído, Version uma string, alfanumérica,Release da versão, Architecture, string definindo arquitetura do alvo.

Packages (Pacotes)

Muitos comandos usam o parâmetro <package-spec> para selecionar pacotes. Esse argumento é comparado com NEVRAs de pacotes, provides e file provides. Quando <package-spec> é um nome de pacote ou um provide, o usuário pode fornecer regras adicionais de restrição para corresponder aos argumentos. Comparações de versão podem usar os operadores lógicos =, >, <, >=, <= como, por exemplo, <package-spec>>= <version>, onde o argumento <version> está no formato [EPOCH:]VERSION[-RELEASE] conforme especificado acima.

<package-file-spec> é similar a <package-spec>, exceto que provides matching não é executado. Portanto, <package-file-spec> é correspondido somente com NEVRAs e file provides. <package-name-spec> é correspondido somente com NEVRAs.

Bibliografia

DNF5, Descrição dos Comandos

Junto com essas notas as seguintes páginas podem ser consultadas:

Descrição dos comandos do DNF5


A descrição dos comandos listada abaixo é uma versão um pouco resumida dos documentos Read the Docs. Em todos os casos, nessa página, o comando dnfé um aliás para dnf5.

Comando advisory

Uso: dnf5 advisory [options] [<advisory-spec>...

advisory permite vários tipos de consultas para obter recomendações e advertências sobre pacotes. Argumentos opcionais podem ser passados em <advisory-spec> ​​para filtrar recomendações com nomes específicos.

Subcomandos:

list Lista recomendações disponíveis.
info Imprime detalhes sobre recomendações.
summary Imprime um resumo das recomendações.

Opções:

–all Mostra recomendações contendo qualquer versão dos pacotes instalados.
–available Mostra recomendações contendo versões mais recentes dos pacotes instalados. (Default).
–installed Mostra recomendações contendo versões iguais e mais antigas dos pacotes instalados.
–updates Mostra recomendações de versões mais recentes dos pacotes instalados, se existir versão mais recente disponível.
–contains-pkgs=NOME_DO_PACOTE,… Mostra apenas recomendações contendo pacotes com nomes especificados.
Esta é uma opção de lista.
Somente pacotes instalados são correspondidos. Podem ser usados globs.
–security Considera somente o conteúdo contido em avisos de segurança.
–bugfix Considera somente o conteúdo contido em avisos de correção de bugs.
–enhancement Considera somente o conteúdo contido em avisos de aprimoramento.
–newpackage Considera somente o conteúdo contido em avisos de newpackage.
–advisory-severities=ADVISORY_SEVERITY,… Considera somente o conteúdo contido em avisos com gravidade especificada.
Esta é uma opção de lista.
Os valores aceitos são: critical, important, moderate, low, none.
–bzs=BUGZILLA_ID,… Considera somente o conteúdo contido em avisos que corrigem um tíquete de ID do Bugzilla fornecido.
Esta é uma opção de lista.
Os valores esperados são IDs numéricos, por exemplo. 123123.
–cves=CVE_ID,… Considera apenas o conteúdo contido em avisos que corrigem um tíquete de ID CVE (Common Vulnerabilities and Exposures) fornecido.
Esta é uma opção de lista.
Os valores esperados são IDs de string no formato CVE, por exemplo, CVE-2201-0123.
–with-bz Mostra apenas avisos que fazem referência a um tíquete do Bugzilla.
–with-cve Mostra apenas avisos que fazem referência a um tíquete CVE.

Exemplos:

# mostra informações e avisos sobre o nome fornecido.
$ dnf advisory FEDORA-2022-07aa56297a

# mostra resumo dos avisos sobre pacotes kernel ou kernel-core com referência a tíquetea do Bugzilla.
$ dnf advisory summary --contains-pkgs=kernel,kernel-core --with-bz

# mostra lista de avisos de segurança ou avisos com gravidade importante
$ dnf advisory list --security --advisory-severities=important

Comando autoremove

Uso: dnf autoremove

autoremove é usado para remover do sistema pacotes desnecessários. Esses pacotes foram provavelmente instalados como dependências para algum aplicativo mais tarde desinstalado, e não são mais exigidos por nenhum aplicativo.

Nota: Pacotes somente de instalação (por exemplo, kernels) nunca são removidos automaticamente por este comando, mesmo que tenham sido instalados como dependências.

A opção –offline armazena a transação para ser executada offline. Essas transações são executadas quando o sistema é inicializado em um ambiente mínimo, o que pode ser mais seguro do que a execução em um sistema inicializado normalmente, já que a transação tem menos probabilidade de interferir em processos sendo executados.
Opção:

–offline Armazena a transação para ser executada offline.Veja opção offline

Exemplos de uso:

$ sudo dnf autoremove
[sudo] senha para guilherme: 
 Pacote                   Arch        Versão              Repositório       Tamanho
 perl-Mozilla-CA          noarch      20240730-1.fc41     anaconda          9.8 KiB

Is this ok [y/N]: y
Executando transações
[1/2] Preparar transação                                         100% |   2.0   B/s |   1.0   B |  00m00s
[2/2] Removendo perl-Mozilla-CA-0:20240730-1.fc41.noarch         100% |  13.0   B/s |   6.0   B |  00m00s

# para postergar a execução para ambiente mínimo
$ sudo dnf autoremove --offline
➡ Nada a fazer!

Comando check

Uso: dnf check [options]

Verifica o banco de dados packagedb local e responde com informações sobre problemas encontrados. Os testes a serem executados podem ser selecionados com as opções:
Opções:

–dependencies exibe dependências faltantes e conflitos.
–duplicates exibe pacotes duplicados.
–obsoleted exibe pacotes obsoletos.
$ dnf check
$ dnf check --dependencies
$ dnf check --duplicates
$ dnf check --obsoleted
# nenhuma mesagem 'exibido porque o sistema está livre de problemas

Comando check-upgrade

Uso: dnf check-upgrade [options] [<package-spec>...]

Faz uma verificação não interativa para atualizações disponíveis do pacote específico. Se nenhum <package-spec> for especificado o comando verifica por atualizações de todos os pacotes do sistema. Termina exibe no terminal o código 0 se não existirem atualizações; e o código 100, junto com lista dos pacotes, se existirem.
Opções: As seguintes opções podem se usadas:

–changelogs Imprime os changelogs do pacote,
–advisories=ADVISORY_NAME,… Considera apenas o conteúdo contido em avisos com nome especificado.
Esta é uma lista de opções.
Os valores esperados são IDs de avisos, por exemplo, FEDORA-2201-123.
–advisory-severities=ADVISORY_SEVERITY,… Considera apenas o conteúdo contido em avisos com gravidade especificada.
Esta é uma lista de opções. Os valores aceitos são:critical, important, moderate, low, none.
–bzs=BUGZILLA_ID,… Considera apenas o conteúdo contido em avisos que corrigem um tíquete com um ID do Bugzilla.
Esta é uma lista de opções. Valores esperados são IDs numéricos, por exemplo, 123123.
–cves=CVE_ID,… Considera apenas o conteúdo contido em avisos que corrigem um tíquete CVE (Common Vulnerabilities and Exposures) com ID fornecido.
Esta é uma lista de opções. Os valores esperados são IDs de string no formato CVE, por exemplo, CVE-2201-0123.
–security Considera apenas o conteúdo contido em avisos de segurança.
–bugfix Considera apenas o conteúdo contido em avisos de correção de bugs.
–enhancement Considera apenas o conteúdo contido em avisos de aprimoramento.
–newpackage Considera apenas o conteúdo contido em avisos de novo pacote.
–minimal Relata as versões mais baixas de pacotes que corrigem avisos do tipo bugfix, enhancement, security ou
newpackage. Se uma opção que limite avisos seja usada, o relato inclui as versões mais antigas de pacotes
que corrigem avisos correspondentes às propriedades de aviso selecionadas

Exemplos:

# imprime lista de pacotes que têm atualizações disponíveis
$ dnf check-upgrade

# imprime logs de alterações para todos os pacotes com atualizações pendentes
$ dnf check-upgrade --changelogs

Comando clean

Uso: dnf clean [options] <cache_types>...

O comando dnf clean é usado para apagar metadata temporariamente matido em repositórios, ou para marcar que um cache está expirado.
Os argumentos em <cache_types> especificam que tipo de dados em cache devem ser limpos.
Argumentos:

all apaga todos os dados temporários de repositórios no sistema,
packages apaga todos os pacotes em cache,
metadata apaga metadados dos repositórios. Isso apaga os arquivos que o DNF5 usa para determinar a disponibilidade remota dos pacotes. Usando essa opção fará com que o DNF baixe todos os metadados em sua próxima execução,
dbcache apaga os arquivos de cache gerados pelo repositório, forçando o DNF a regenerar o cache em sua próxima execução,
expire-cache marca como expirados os metadados do repositório, forçando o DNF a verificar a disponibilidade do cache em sua próxima execução.

Exemplos: Alguns exemplos de uso:

# limpa todos os dados em cache no repositório
$ dnf clean all

# limpa todos os pacotes em cache e metadados no dbcache
$ dnf clean packages dbcache

Comando distro-sync

Uso: dnf distro-sync [options] [<especificação-pacote>...]

O comando dnf distro-sync serve para sincronizar os pacotes instalados com sua versão mais recente disponível em qualquer dos repositórios habilitados. Ele pode ser usado para atualizar, fazer downgrade ou manter pacotes. Argumentos opcionais podem especificar pacotes a serem sincronizados:
Opções:

–allowerasing permitir a remoção de pacotes instalados para resolver quaisquer problemas potenciais de dependência,
–skip-broken Resolver quaisquer problemas de dependência removendo pacotes que estejam causando problemas da transação,
–skip-unavailable Permitir pular pacotes que não são possíveis de sincronizar. Todos os pacotes restantes serão sincronizados,
–downloadonly Baixar o conjunto de pacotes resolvidos sem executar uma transação RPM,
–offline Armazenar a transação a ser executada offline. Veja o comando Offline.

Exemplos de uso:

# sincroniza todo o sistema com a versão mais recente disponível dos pacotes.
$ dnf distro-sync

# Sincroniza o pacote vim com a versão mais recente disponível.
$ dnf distro-sync vim

Comando downgrade

Uso: dnf downgrade [opções] <package-spec>...

downgrade é usado para fazer o downgrade dos pacotes especificados na lista package-spec. É escolhida a versão mais alta, abaixo da versão sendo substituída, quando possível. Se a versão passada no argumento é inferior à versão instalada, o downgrade se dá para esta versaõ especificada.
Opções:

–allowerasing Permite remover pacotes instalados para solucionar problemas de dependência.
–skip-broken Resolve problemas de dependência removendo pacotes que estão causando problemas na transação.
–skip-unavailable Ignora pacotes que não podem passar por rebaixamento. Os demais pacotes são rebaixados.
–allow-downgrade Permite o rebaixamento de dependências na operação solicitada.
–no-allow-downgrade Desabilita o rebaixamento de dependências na operação solicitada.
–downloadonly Baixa os pacotes exigidos sem executar nenhuma transação RPM.
–offline Armazena a transação para ser executada offline. Veja o comando Offline.

Nessa tabela usamos rebaixar para a expressão downgrade, que significa passar para uma versão inferior
Exemplos de uso:

# downgrade do pacote nano para a versão fornecida
$ dnf downgrade nano-0:6.0-2.fc36

# Faça downgrade gcc e glibcpacotes, permitindo a remoção de pacotes instalados quando necessário
$ dnf downgrade gcc glibc --allowerasing

Comando download

Uso: dnf download [options] <package-spec>...

download é usado para baixar pacotes binários de origem definidos nos argumentos package-spec para o diretório de trabalho atual.
Opções:

–arch Limita a pacotes de arquiteturas dadas.
–resolve Resolve dependências de pacotes especificados e baixa os que faltam.
–alldeps Usado junto com –resolve, baixa todas as dependências, inclusive as já instaladas.
–destdir=<path> Define o diretório usado para baixar pacotes. O default é o diretório atual.
–srpm Baixa o rpm de origem e habilita todos os repositórios utilizados.
–url Imprime a lista de URLs onde os rpms podem ser baixados, sem fazer nenhum download.
–urlprotocol Usado junto com –url, filtra as URLs para os protocolos especificados: http, https, ftp, ou file. Pode ser usada várias vezes.
–allmirrors Usado com –url, imprime URLs separadas por espaços de todos os mirrors disponíveis para cada pacote.

Exemplos de uso:

# Baixa o pacota kernel-headers usando o formato NEVRA completo. 
$ dnf download kernel-headers-0:5.17.0-300.fc36.i686

# Baixa todos os pacotes com o nome rpm ou rpm-devel.
$ dnf download rpm rpm-devel

# Baixe o pacote maven-compiler-plugin com todas as dependências.
$ dnf download maven-compiler-plugin --resolve --alldeps

# Baixa o pacote maven-compiler-plugin para o diretório /temp/pacotes.
$ dnf download --destdir /temp/pacotes maven-compiler-plugin

# Lista a URL http para baixar o pacote python.
$ dnf download --url --urlprotocol http python

# Baixa o python com a arquitetura x86_64.
$ dnf download python --arch x86_64

# Baixe o rpm do dnf.
$ dnf download dnf --srpm

Comando environment

Uso: dnf environment <subcommand> [options] [...]

environment faz consultas sobre ambientes e grupos relacionados a eles. Argumentos opcionais em environment-spec servem como filtros para selecionar ambientes.
Subcomandos:

list Lista ambientes disponíveis.
info Imprime detalhes sobre os ambientes.

Opções:

–available Mostra ambientes disponíveis mas não instalados.
–installed Mostrar apenas ambientes instalados.

Exemplos de uso:

# Mostrar lista de todos os ambientes.
$ dnf environment list

# Mostrar informações detalhadas sobre o KDEambiente.
$ dnf environment info "KDE Plasma Workspaces"

Comando group

Uso: dnf group {list|info} [options] [...]

Uso: dnf group {install|remove|upgrade} [options] ...

group permite consultas para obter informações sobre grupos, pacotes relacionados a eles e também é usado para instalação de grupos. Para consultar ambientes, use environment.
Nota: dnf4 lista ambientes e grupos com o comando group.

Argumentos opcionais podem ser passados em group-spec ​​para filtrar grupos.
Subcomandos

list Lista todos os grupos correspondentes, instalados e disponíveis. Se nenhum parâmetro for especificado, lista os grupos conhecidos. As opções –installed e –available restringem a lista solicitada. Se –hidden for usado grupos ocultos também são listados.
info Imprime informações detalhadas sobre grupos. Aceita as mesmas opções que list.
install Marca grupos especificados e instala seus pacotes. Se a –with-optional for especificado, pacotes opcionais são inclídos. Por default todos os pacotes Mandatory e Default serão instalados se possível. Pacotes condicionais são instalados se atenderem aos requisitos. [Pode ser configurado por dnf-conf(5) , group_package_types].
Se o grupo estiver parcialmente instalado, o comando instala os pacotes ausentes.
–no-packages faz com que nenhum pacote novo seja instalado. Apenas pacotes de grupos instalados são considerados para instalação.
remove Remove os pacotes do sistema e marca o grupo como removido. Ignora pacotes que pertencem a outro grupo instalado e não foram instalados pelo usuário.
Se –no-packages for usada, nenhum pacote será removido.
upgrade Atualiza a definição do grupo especificado e os pacotes desse grupo. Caso novos pacotes sejam adicionados à definição do grupo após sua instalação, os novos pacotes serão instalados. Se alguns pacotes forem removidos da definição do grupo, eles serão desinstalados, exceto se foram instalados por um motivo diferente (por exemplo, instalados explicitamente por um usuário ou instalados implicitamente como uma dependência).

Opções para list e info:

–available Mostra só grupos disponíveis, não instalados mas são conhecidos pelo DNF5.
–installed Mostra apenas grupos instalados.
–hidden Inclui grupos ocultos.
–contains-pkgs Mostra apenas grupos contendo pacotes com nomes especificados. A opção list suporta globs.

Opções para install, remove e upgrade:

–with-optional Inclui pacotes opcionais dos grupos, usado com install.
–no-packages Opera exclusivamente nos grupos sem manipular nenhum pacote. Usado com install e remove.
–allowerasing Permite a remoção de pacotes instalados para resolver problemas de dependência. Usado com os comandos install e upgrade.
–skip-broken Resolve problemas de dependência removendo os pacotes que causam problemas na transação. Usado com install.
–skip-unavailable Permite que se ignore pacotes que não podem ser instalados ou atualizados. Usado com install e upgrade.
–allow-downgrade Permite o downgrade de dependências para resolver a operação solicitada. Usado com install e upgrade.
–no-allow-downgrade Impede o downgrade de dependências ao resolver a operação solicitada. Usado com os install e upgrade.
–downloadonly Baixa os pacotes requeridos sem executar uma transação RPM.
Usado com install e upgrade.
–offline Armazena a transação para ser executada offline. Veja o comando Offline.

Exemplos de uso:

# Mostra lista de todos os grupos, incluindo os ocultos
$ dnf group list --hidden

# Mostrar informações detalhadas sobre todos os grupos relacionados a Xfce
$ dnf group info *xfce*

# Instalar o grupo mysql incluindo pacotes opcionais.
$ dnf group install mysql --with-optional

# Atualiza pacotes do grupo mysql em conformidade com a definição atual do grupo.
$ dnf group upgrade mysql

Comando history

Uso: dnf history <subcommand> [options] []

history permite exibe um histórico de transações e oferece opções sobre esses transações, como desfazer ou refazer uma transação. Pressupõe-se que a opção de configuração history_record estava ajustadas quando as transações foram efetuadas.

Subcomandos:

list Lista informações sobre transações registradas no sistema.
info Imprime detalhes sobre transações específicas.
undo Desfaz todas as ações da transação especificada.
redo Repete a transação especificada.
Usa automaticamente –ignore-extras e –ignore-installed.
Diferente dos demais comandos do history, ele sobreescreve os motivos das transações de pacotes já instalados.
Útil para finalizar transações interrompidas.
rollback Desfaz todas as transações realizadas após a transação especificada.
store Armazena a transação em um diretório.

Opções para list e info:

–reverse Inverte a ordem das transações listadas.

Opções para undo, rollback e redo:

–skip-unavailable Permite ignorar e pular ações sobre pacotes não são possíveis de executar.

Opções para undo e rollback:


–ignore-extras
Ignaora pacotes extras incluídos na transação como erros. Mesmo assim eles são reportados como avisos.
–ignore-installed Não trata como erro a incompatibilidades entre pacotes de transações instalados e armazenados.
Mesmo assim são reportados como avisos. O uso dessa opção pode resultar em uma transação vazia.
Para ações de instalação, pule os pacotes já instalados.
Para ações de atualização, ignore grupos ou ambientes que não estão instalados.
Para remover ações, pule pacotes/grupos/ambientes não instalados.

Exemplos de uso:

# Lista todas as transações, da mais recente para mais antigas.
$ dnf history list

# Mostra informações detalhadas sobre a quarta transação.
$ dnf history info 4

# Mostra informações detalhadas sobre a última transação.
$ dnf history info last

# Mostra informações detalhadas sobre a penúltima transação.
$ dnf history info last-1

# Lista transações com ID no intervalo de 4 a 8.
$ dnf history list 4..8

# Desfaz a última transação.
$ dnf history undo last

# Desfaça a quarta transação ignorando pacotes baixados para a transação de reversão
$ dnf history undo 4 --ignore-extras

Comando info

Uso: dnf info [options] [<package-spec>...]

Imprime informações detalhadas sobre os pacotes com base nos parâmetros fornecidos.
Opções:

–showduplicates Mostra todas as versões dos pacotes, e não apenas a mais recente.
–installed Lista só pacotes instalados.
–available Lista apenas pacotes disponíveis.
–extras Lista apenas extras (pacotes instalados no sistema mas não disponíveis em nenhum repositório conhecido).
–obsoletes Lista apenas os pacotes instalados que estão obsoletos em relação a pacotes de qualquer repositório conhecido.
–recent Lista só pacotes adicionados recentemente aos repositórios.
–upgrades Lista apenas as atualizações disponíveis para os pacotes instalados.
–autoremove Lista apenas os pacotes que serão removidos pelo comando autoremove.

Exemplos de uso:

# mostra informações detalhadas sobre pacotes instalados e disponíveis.
$ dnf info

# Imprime informações sobre pacotes recentes cujos nomes começam por gnome.
$ dnf info --recent gnome*

Comando install

Uso: dnf install [options] <package-spec>|@|@...

install é usado para instalar pacotes, grupos ou ambientes. Ao instalar pacotes definidos em package-specargumentos, DNF5garante que os pacotes e suas dependências estejam instalados no sistema. Se os pacotes especificados já estiverem instalados, o DNF5 não verifica suas dependências novamente e simplesmente verifica se os pacotes em si estão presentes.

Ao instalar grupos definidos nos argumentos group-spec, DNF5 garante que os grupos e seus pacotes sejam instalados no sistema. Instala apenas pacotes de grupo que correspondem ao tipo de pacote configurado.
Opções:

–allowerasing Permite a remoção de pacotes instalados para resolver problemas de dependência.
–skip-broken Resolve problemas de dependência removendo os pacotes que estão causando problemas da transação.
–skip-unavailable Permite pular pacotes que não estão disponíveis em repositórios. Todos os pacotes disponíveis são instalados.
–allow-downgrade Habilite o downgrade de dependências ao resolver a operação solicitada.
–no-allow-downgrade Desabilite o downgrade de dependências ao resolver a operação solicitada.
–downloadonly Baixe o conjunto de pacotes resolvido sem executar uma transação RPM.
–offline Armazene a transação a ser executada offline. Veja o comando Offline.
–advisories=ADVISORY_NAME,… Considere apenas o conteúdo contido em avisos com nome especificado. Esta é uma opção de lista.
Os valores esperados são IDs de consultoria, por exemplo, FEDORA-2201-123.
–advisory-severities=ADVISORY_SEVERITY,… Considere apenas o conteúdo contido em avisos com gravidade especificada.
Esta é uma opção de lista.
Os valores aceitos são: critical, important, moderate, low, none.
–bzs=BUGZILLA_ID,… Considere apenas o conteúdo contido em avisos que corrigem um tíquete de um determinado ID do Bugzilla.
Esta é uma opção de lista.
Os valores esperados são IDs numéricos, por exemplo, 123123.
–cves=CVE_ID,… Considere apenas o conteúdo contido em avisos que corrigem um tíquete de determinado ID CVE (Common Vulnerabilities and Exposures).
Esta é uma opção de lista.
Os valores esperados são IDs de string no formato CVE, por exemplo, CVE-2201-0123.
–security Considere apenas o conteúdo contido em avisos de segurança.
–bugfix Considere apenas o conteúdo contido em avisos de correção de bugs.
–enhancement Considere apenas o conteúdo contido em avisos de aprimoramento.
–newpackage Considere apenas o conteúdo contido nos avisos do novo pacote.

Exemplos de uso:

# Instala o pacote tito.
$ dnf install tito

# Instala o arquivo rpm no diretório fornecido.
$ dnf install ~/Downloads/tito-0.6.21-1.fc36.noarch.rpm

# Instala o pacote tito na versão especificada.
# Se o pacote já estiver instalado, ele tentará fazer o downgrade ou o upgrade para a versão dada.
$ dnf install tito-0.6.21-1.fc36

# Instala todos os pacotes que pertencem ao FEDORA-2022-07aa56297 advisory.
$ dnf install --advisory=FEDORA-2022-07aa56297a \*

Comando leaves

O comando leaves serve para todos os pacotes “leafes” (folhas). Pacotes “leafes” são aqueles que estão instalados mas não são dependência de outro pacote instalado. Isso ocorre, por exemplo, quando dois ou mais pacotes marcam um ao outra como dependência, em um ciclo fechado, embora não sejam exigidos por nenhum outro pacote. Esse comando lista pacotes classificados por grupo, sendo o primeiro pacote no grupo marcado pelo caracter .
Opções:
leaves não possui opções, embora considere a configuração install_weak_deps. Se install_weak_deps = false as dependências fracas são ignoradas durante o processamento do conjunto de pacotes leaves.

Por que isso é útil? A lista de pacotes leaves dá uma visão geral e enxuta do que está instalado no sistema. Todos os pacotes que aparecem na lista de leaves podem ser desinstalados sem quebrar nenhuma dependência do sistema.
Exemplo de uso:

# para listar os pacotes "leaves"
$ sudo dnf leaves	
- bluedevil-0:6.2.3-1.fc41.x86_64
- bluez-cups-0:5.79-1.fc41.x86_64
- breeze-gtk-gtk2-0:6.2.3-1.fc41.noarch
- breeze-gtk-gtk3-0:6.2.3-1.fc41.noarch
- breeze-gtk-gtk4-0:6.2.3-1.fc41.noarch
- brltty-0:6.6-19.fc41.x86_64
- cifs-utils-0:7.1-2.fc41.x86_64
- cifs-utils-info-0:7.1-2.fc41.x86_64
# [a lista está truncada]

# para remover "bluedevil-0:6.2.3-1.fc41.x86_64"
$ sudo dnf remove bluedevil-0:6.2.3-1.fc41.x86_64

Nota: Esse comando deve ser usado com cautela para que não sejam removidos pacotes usados pela sistema.

Comando list

Uso: dnf list [options] [<package-spec>...]

O comando list exibe uma lista de pacotes, que pode ser modificada pelos parâmetros fornecidos.
Opções:

–showduplicates Mostra todas as versões dos pacotes, não só a mais recente.
–installed Lista apenas os pacotes instalados.
–available Lista os pacotes disponíveis.
–extras Lista apenas os extras (aqueles instalados no sistema que não estão disponíveis em nenhum repositório conhecido).
–obsoletes Lista os pacotes instalados no sistema tornados obsoletos por pacotes em outro repositório conhecido.
–recent Lista só pacotes adicionados recentemente aos repositórios.
–upgrades Lista apenas as atualizações disponíveis para os pacotes instalados.
–autoremove Lista os pacotes que serão removidos pelo comando autoremove.

Exemplos de uso:

# para listar pacotes instalados e disponíveis.
$ dnf list

# lista todos os pacotes disponíveis, incluindo todas as versões disponíveis.
$ dnf list --available --showduplicates

# lista pacotes instalados e disponíveis com nome iniciado por kde.
$ dnf list kde*

Comando makecache

Uso: dnf makecache [global options]

makecache é usado para criar e baixar metadados para repositórios habilitados. Sempre que possível ele tenta evitar o download de novos dados, por exemplo, quando os metadados locais ainda não expiraram.

dnf makecache atualiza o cache de metadados DNF local. Não há necessidade de executá-lo manualmente porque o DNF atualiza o cache de metadados automaticamente sempre que for executado. Esse comando é normalmente invocado de forma não interativa, por exemplo por um timer systemd, para manter o cache de metadados atualizado.
Exemplo de uso:

# esvazia o diretório /var/cache/libdnf/
$ sudo dnf clean all

# atualiza /var/cache/libdnf/ com infirmações sobre repositórios
$ sudo dnf makecache

# esvazia os repositórios em /var/cache/libdnf/
$ sudo dnf clean metadata

# esvazia caches de repositórios em /var/cache/libdnf/
$ sudo dnf clean all

Comando mark

Uso: dnf mark <subcommand> [global options] [] <package-spec>...

Quando pacotes são instalados com dnf um “motivo” para a instalação fica armazendo nos metadados do banco de dados. mark altera o motivo para essa instalação. Esse motivo fica definido no argumento package-spec.
Subcomandos:

user Marca o pacote como instalado pelo usuário. Útil se um pacote foi instalado como dependência mas o usuário quer marcá-lo para permanecer no sistema quando o comando remove for usado junto com a opção clean_requirements_on_remove=True.
dependency Marca o pacote como uma dependência. Útil se o usuário precisa de um pacote específico. O pacote permanece instalado no sistema, mas pode ser removido com remove, usado junto com a opção clean_requirements_on_remove=True.
Essa operação deve ser usada no lugar de remove se não há certeza de que pacote não é requisito para outro pacote instalado no sistema por outro usuário.
weak Marca o pacote como uma dependência fraca.
group Marca o pacote como instalado pelo grupo definido no argumento group-id.
Útil se um pacote foi instalado como uma dependência por um usuário, mas espera-se que ele seja protegido e tratado como pertencente a um grupo, pelo comando group remove.

Opções:

–skip-unavailable Permite pular pacotes que não instalados no sistema. Pacotes instalados serão marcados.

Exemplos de uso:

# marca o pacote fuse-devel como instalado pelo usuário
$ dnf mark user fuse-devel

# marca o pacote vim-enhanced como instalado pelo grupo xfce-desktop
$ dnf mark group xfce-desktop vim-enhanced

Comando module

Uso: dnf module <subcommand> [options] [...]

Modularidade é uma forma alternativa de montar, organizar e entregar pacotes. Atualmente, existe apenas suporte básico para gerenciar os módulos, que não recebem mais suporte nas principais distribuições RPM. Mais detalhes em: Modularity e Read The Docs.

Comando offline

Uso: dnf offline <subcommand> [options]

offline é utilizado para gerenciar transações “offline”, que são aquelas executadas quando o sistema é inicializado num ambiente mínimo. Nesse ambiente, rodando um número menor de processos, é mais seguro executar transações pois é menos provável que a transação interfira com os processos em execução.

Transações offline podem ser iniciadas com o “flag” –offline em qualquer operação (install upgrade distro-sync, etc.), ou via dnf system-upgrade download. Depois que uma transação offline é iniciada podemos executar dnf offline reboot para reiniciar o computador e começar a transação. Os dados para transações offline são armazenados no diretório system state, localizado em /usr/lib/sysimage/libdnf/offline.
Subcomandos:

clean Remove transações offline armazenada e exclui arquivos de pacotes em cache.
log Mostra uma lista de inicializações usadas para transações offline, ou mostra logs de transações offline tentadas. Os logs para cada reinicialização podem ser mostrados com a especificação de um dos números na primeira coluna com o argumento –number. Números negativos são usados para listar boots em ordem reversa, começando no último. Por exemplo, log –number=-1 mostra logs da última transação.
reboot Prepara o sistema para executar transações offline e reinicializa para executar a transação. Só pode ser executado após uma transação offline ser iniciada (por exemplo, por dnf system-upgrade download).
status Mostra o status da transação offline atual.
_execute Executa a transação no ambiente offline.
Aviso: apenas para uso interno, não devendo ser executado pelo usuário.

Opções:

–number=<boot number> Mostra o log especificado pelo número. Para ver o número do log execute dnf offline log--number. Usado com o subcomando log.
–poweroff Desliga o sistema após a conclusão da transação, em vez de reiniciar. Se a transação falhar, o sistema será reiniciado em vez de desligar mesmo com esse sinalizador. Usado com o subcomando reboot.

Exemplos de uso:

# prepara a instalação do pacote "hello" como uma transação offline.
$ dnf install --offline hello

# mostra o status da transação offline atual.
$ dnf offline status

# reinicia, executa a transação offline e depois desliga o sistema.
$ dnf offline reboot --poweroff

# Lista os "boots" em que uma transação offline foi tentada.
$ dnf offline log

# Visualiza o log da inicialização mais recente em que uma transação offline foi tentada.
$ dnf offline log --number=-1

Comando provides

Uso: dnf provides [global options] <package-spec>...

provides encontra os pacotes que fornecem o <package-spec>. As especificações podem ser combinadas por nome do arquivo e specs.
Exemplos de uso:

# mostra quais pacotes fornecem o comando tito.
$ dnf provides tito

# mostra quais pacotes fornecem o arquivo /usr/bin/tito
$ dnf provides /usr/bin/tito

# retorna o pacote para rpm e informa se nonexistent_package não retorna resultados.
$ dnf provides rpm nonexistent_package

Nota: Quando nenhum pacote é encontrado por provides, o dnf retorna o código 1 e a lista os recursos que não foram encontrados.

Comando reinstall

Uso: dnf reinstall [global options] <package-spec>...

reinstall é usado para reinstalar pacotes definidos em <package-spec>.
Opções:

–allowerasing Permite remover pacotes instalados para resolver problemas de dependência.
–skip-broken Resolva os problemas de dependência removendo pacotes que causam problemas na transação.
–skip-unavailable Ignora pacotes que não podem ser reinstalaos. Os demais serão reinstalados.
–allow-downgrade Permite o downgrade de dependências para resolver a operação solicitada.
–no-allow-downgrade Desativa o downgrade de dependências ao resolver a operação solicitada.
–downloadonly Baixa o conjunto de pacotes resolvidos sem executar uma transação RPM.
–offline Armazena a transação a ser realizada offline.

Exemplos de uso:

# reinstala o pacote tito.
$ dnf reinstall tito

# reinstala o pacote tito usando arquivo rpm local.
# Útil quando o pacote não está disponível em repositórios habilitados.
$ dnf reinstall ~/Downloads/tito-0.6.21-1.fc36.noarch.rpm

Comando remove

Uso: dnf remove [options] <package-file-spec>|@|@...

remove é usado para remover pacotes, grupos ou ambientes do sistema. Para manter as dependências instaladas junto com o pacote a remover, defina clean_requirements_on_remove = False.
Opções:

–no-autoremove Desativa a remoção de dependências não mais usadas.
–offline Armazena a transação a ser realizada offline.

Exemplos de uso:

# remove o pacote tito.
$ dnf remove tito

Comando replay

Uso: dnf replay [options]

replay permite reexecutar uma transação armazenada no diretório . O diretório de transações pode ser criado com a opção –store, disponível em todos os comandos de transação. A reexecução realizará as mesmas operações sobre pacotes da transação original, retornando erro caso existe diferenças com os pacotes instalados ou suas versões.

Para executar a repetição, o diretório de transações deve conter um arquivo no formato JSON (com o nome transaction.json) descrevendo as operações. O diretório também pode conter pacotes, grupos ou ambientes que serão usados na transação reproduzida.
Opções:

–ignore-extras Não considera como erros pacotes extras baixados pela transação. Eles ainda são relatados como avisos.
–ignore-installed Não considera erros as incompatibilidades entre pacotes de transação instalados e armazenados. Eles ainda serão relatados como avisos.
Em ações de instalação, ignore pacotes já instalados. Em ações de atualização, ignore grupos ou ambientes ainda não instalados.
Em ações de remoção, ignore pacotes/grupos/ambientes não instalados. Essa opção pode levar a transações vazias.
–skip-broken Resolve problemas de dependência removendo pacotes que causam problemas na transação.
–skip-unavailable Ignore pacotes armazenados na transação não disponíveis no sistema de destino, sem gerar mensagem de erro.

Exemplos de uso:

# Reexecuta transação armazenada em ./transaction.
$ dnf replay ./transaction

# Reexecuta transação armazenada em ./transaction ignorando pacotes não disponíveis.
$ dnf replay ./transaction --skip-unavailable

Comando repo

Uso: dnf repo <subcommand> [options] [...]

repo permite diversos tipos de consultas sobre repositórios configurados no sistema.

Subcomandos:

list Lista repositórios disponíveis.
info Mostra informações detalhadas sobre os repositórios.

Opções:

–all Mostra informações sobre todos os repositórios conhecidos.
–enabled Mostra informações apenas sobre repositórios habilitados. (Default).
–disabled Mostra informações apenas sobre repositórios desativados.

Exemplos de uso:

# imprime informações detalhadas sobre todos os repositórios conhecidos.
$ dnf repo info --all

# imprime repositórios desativados relacionados à depuração.
$ dnf repo list --disabled *-debuginfo

# desative persistentemente o repositório usando o plugin config-manger.
$ dnf config-manger setopt repo_id.enabled=0

Comando repoquery

Uso: dnf repoquery [options] [...]

repoquery é usado para consultar pacotes correspondentes a diversos critérios fornecido pelo usuário. Argumentos definidos na lista spec são usados como <package-file-spec>.

Opções:

–advisories=ADVISORY_NAME,… Limita a pacotes em advisory com nome especificado. Esta é uma opção de lista.
Valores esperados são IDs advisory, por exemplo:FEDORA-2201-123.
–advisory-severities=ADVISORY_SEVERITY,… Limita a pacotes em advisory com gravidade definida. Esta é uma opção de lista.
Valores aceitos são:critical, important, moderate, low, none.
–arch=ARCH,… Limita a pacotes das arquiteturas especificadas. Esta é uma opção de lista.
–available Consulta pacotes disponíveis. (Default).
Se combinado com –installed consulta pacotes instalados e disponíveis.
–bugfix Limita a pacotes com avisos de correção de bugs.
–bzs=BUGZILLA_ID,… Limita a pacotes em avisos que corrigem um Bugzilla ID.
Esta é uma opção de lista.
Os valores esperados são IDs numéricos, por exemplo: 123123.
–cves=CVE_ID,… Limita a pacotes em avisos que corrijam um ID CVE (Vulnerabilidades e Exposições Comuns).
Esta é uma opção de lista.
Os valores esperados são IDs de string no formato CVE, por exemplo: CVE-2201-0123.
–disable-modular-filtering Inclui pacotes em módulos inativos.
–duplicates Limita a pacotes instalados e duplicados (ou seja, mais versões de pacotes com o mesmo nome e arquitetura).
Pacotes Installonly são excluídos desse conjunto.
–enhancement Limita a pacotes com avisos de aprimoramento.
–exactdeps Limita a pacotes que requerem <capability> especificados por –whatrequires ou –whatdepends.
Esta opção só pode ser empilhada com –whatrequires ou –whatdepends.
–extras Limita a pacotes instalados que não presentes em nenhum repositório disponível.
–file=FILE,… Limita a pacotes que possuem os arquivos em FILE. Esta é uma opção de lista.
–installed Consulta pacotes instalados. Se combinado com –available consulta pacotes instalados e disponíveis.
–installonly Limita a pacotes installonly instalados.
–latest-limit=N Limita a N pacotes mais recentes para uma arquitetura. Se N < 0 usa todos os pacotes.
–leaves Limita a pacotes leaves (instalados mas não exigidos por outros pacotes instalados).
–newpackage Limita a pacotes em avisos de newpackage.
–providers-of=PACKAGE_ATTRIBUTE Obtem o atributo de pacotes selecionados pelo atributom depois que a filtragem é concluída.
Pacotes resultantes são limitados pelas opções –available –installed –arch.
Tem suporte para: conflicts, depends, enhances, obsoletes, provides, recommends, requires, requires_pre, suggests, supplements.
–recent Limita a pacotes alterados recentemente.
–recursive Opção que pode ser usada com –whatrequires ou –providers-of=requires.
Se usado com –whatrequires, estende a saída com pacotes que exigem qualquer coisa fornecida pelos pacotes de saída.
Se usado com –providers-of=requires: estende a saída com pacotes que fornecem qualquer coisa exigida pelos pacotes de saída.
Os pacotes adicionados são limitados pelas opções –available –installed –arch.
–security Limita a pacotes em avisos de segurança.
–srpm Utiliza pacotes RPMs de origem correspondentes para a saída após a filtragem. Habilita repositórios de origem.
–unneeded Limita a pacotes instalados mas desnecessários (pacotes que foram instalados como dependências, não mais necessários).
Lista pacotes que serão removidos com autoremove.
–upgrades Limita a pacotes disponíveis que atualizam alguns pacotes já instalados.
–userinstalled Limita a pacotes que não marcados como dependências ou como dependências fracas.
Isso limita os pacotes que foram instalados a pedido do usuário ou indiretamente, como parte de um perfil de módulo ou grupo de composições. Também retorna pacotes com motivo desconhecido.
O resultado pode ser influenciado pela opção “exclude” no arquivo de configuração.
Para obter a razão exata da instalação, use a opção –queryformat ‘%{name} %{reason}\n‘.
–whatconflicts=CAPABILITY,… Limita a pacotes em conflito com qualquer um dos listados em <capabilities>. Esta é uma opção de lista.
–whatdepends=CAPABILITY,… Limita a pacotes que requerem, melhoram, recomendam, sugerem ou complementam qualquer um em <capabilities>.
Esta é uma opção de lista.
–whatenhances=CAPABILITY,… Limita a pacotes que melhoram qualquer um dos recursos em <capabilities>. Use –whatdepends para listar todos os pacotes dependentes. Esta é uma opção de lista.
–whatobsoletes=CAPABILITY,… Limita a pacotes que tornem obsoletos qualquer um dos <capabilities>. Esta é uma opção de lista.
–whatprovides=CAPABILITY,… Limita a pacotes que fornecem qualquer uma das <capabilities>. Esta é uma opção de lista.
–whatrecommends=CAPABILITY,… Limite a pacotes que recomendam qualquer um dos <capabilities>. Use –whatdepends para listar todos os pacotes dependentes.
Esta é uma opção de lista.
–whatrequires=CAPABILITY,… Limite a pacotes que requeiram qualquer uma das <capabilities>. Use –whatdepends para listar todos os pacotes dependentes.
Esta é uma opção de lista.
–whatsuggests=CAPABILITY,… Limita a pacotes que sugiram qualquer uma das <capabilities><>. Use –whatdepends para listar todos os pacotes dependentes.
Esta é uma opção de lista.
–whatsupplements=CAPABILITY,… Limita a pacotes que complementem qualquer um dos <capabilities>. Use –whatdepends para listar todos os pacotes dependentes.
Esta é uma opção de lista.

Opções de formatação podem ser usadas para definir quais informações são exibidas sobre cada pacote. Leia mais sobre os comandos de formatação em Read the Docs: Repoquery.

As opções de formatação podem ser usadas para definir quais informações são exibidas sobre cada pacote. Os parâmetros listados na tabela abaixo são mutuamente exclusivos, ou seja, apenas um pode ser especificado em cada consulta. Se nenhuma opção for fornecida, os pacotes selecionados serão exibidos no formato de consulta “%{full_nevra}”.

Na tabela abaixo cada uma das opções funciona como a opção dada na segunda coluna, exceto que as duplicações na saída são removidas e as linhas são ordenadas.

Opções de formatação:

Opção: Funciona como:
–conflicts --qf "%{conflicts}"
–depends --qf "%{depends}"
–enhances --qf "%{enhances}"
–files --qf "%{files}"
–obsoletes --qf "%{obsoletes}"
–provides --qf "%{provides}"
–recommends --qf "%{recommends}"
–requires --qf "%{requires}"
–requires-pre --qf "%{requires_pre}"
–sourcerpm --qf "%{sourcerpm}"
–suggests --qf "%{suggests}"
–supplements --qf "%{supplements}"
–location --qf "%{location}"
–info Mostra informações detalhadas sobre o pacote.
–changelogs Imprime os changelogs de pacotes.
–querytags Exibe tags disponíveis para –queryformat.
–queryformat=<format> Formato de exibição para pacotes.
As tags estão descritas na tabela abaixo.

As tags usadas com dnf repoquery --queryformat=<format> estão descritas abaixo. A string <format> pode conter tags (%{<tag>}i) que são substituídos por atributos correspondentes do pacote. Saídas duplicadas são removidas. O default é “%{full_nevra}”.

Tags:

Tag: Exibe:
arch arquitetura do pacote.
buildtime tempo de compilação do pacote, em Unix time.
conflicts recursos em conflito com o pacote.
debug_name nome do pacote debuginfo do pacote
depends as dependências desse pacote. Aprimora, recomenda, sugere ou complementa.
description descrição do pacote.
downloadsize tamanho do download do pacote.
enhances recursos de exibição aprimorados pelo pacote.
epoch epoch (linux data) do pacote.
evr epoch:version-release (versão e lançamento) do pacote. A época 0 é omitida.
files arquivos contidos no pacote.
from_repo id do repositório onde está o pacote. Vazio para pacotes não instalados.
full_nevra name-epoch:version-release.arch do pacote. A época 0 está incluída.
group grupo do pacote. Este não é o grupo Comps.
location local do pacote.
installsize tamanho de instalação do pacote.
installtime tempo de instalação do pacote.
license licença do pacote.
name nome do pacote.
obsoletes recursos tornados obsoletos pelo pacote.
packager empacotador do pacote.
prereq_ignoreinst requisitos requires_pre que podem ser removidos.Vazio para pacotes não instalados.
provides recursos fornecidos pelo pacote.
reason motivo pelo qual os pacotes foram instalados.
recommends recursos recomendados pelo pacote.
regular_requires recursos exigidos pelo pacote sem os requisitos %pre %post %preun e %postun.
release versão do pacote.
repoid id do repositório que contém o pacote.
reponame nome do repositório que contém o pacote.
requires recursos exigidos pelo pacote (combina regular_requires e requires_pre).
requires_pre capacidade exigida pelo pacote (se instalado) para executar seus scripts %pre %post %preun e %postun. Apenas requisitos para %pre e $post para pacote não instalado.
source_debug_name nome do pacote debuginfo para o pacote de origem.
source_name nome do RPM de origem do pacote.
sourcerpm fonte RPM do pacote.
suggests recursos sugeridos pelo pacote.
summary resumo do pacote.
supplements capacidades suplementadas pelo pacote.
url url do pacote.
vendor fornecedor do pacote.
version versão do pacote.

Nota: as tags marcadas com produzem um output com linhas separadas por quebras de linha.

Exemplos de uso:

# listar pacotes que fornecem o arquivo /etc/koji.conf.
$ dnf repoquery /etc/koji.conf

# listar pacotes que contêm o "http" no nome.
$ dnf repoquery *http*

# listar pacotes instalados incluídos em qualquer advisory de segurança.
$ dnf repoquery --installed --security

Comando search

Uso: dnf search [options] <pattern>...

search é usado para pesquisar pacotes em correspondência com palavras-chave fornecida pelo usuário, em vários metadados. Por padrão, o comando procura todas as chaves solicitadas (usando AND) nos campos Name ou Summary dos metadados do pacote RPM. A correspondência é insensível ao caso (maíuscula/minúsculas) e globs são suportados.
Opções:

–all A busca por padrões de pesquisa inclui os campos Description e URL, nos metadados.
Com essa opção, a pesquisa lista os pacotes que correspondem a pelo menos uma das chaves (usando OR).
–showduplicates Mostra todas as versões de pacotes, não apenas as mais recentes.

Exemplos de uso:

# procura a palavra-chave kernel nos campos Name ou Summary dos metadados do pacote.
$ dnf search kernel

# procura pacotes com palavras-chaves rpm e dbus (ambos) nos campos Name ou Summary.
$ dnf search rpm dbus

# procura pacotes com qualquer uma das palavras-chave nos campos Name, Summary, Description ou URL.
$ dnf search --all fedora gnome kde

Comando swap

Uso: dnf swap [options]

swap é usado para remover um pacote e instalar outro em uma única transação.
Opções:

–allowerasing Permite que pacotes instalados sejam removidos para resolver problemas de dependência.
–offline Armazena a transação para execução offline.

Exemplos de uso:

# Remove mlocate e instala plocate.
$ dnf swap mlocate plocate

Comando system-upgrade

Uso: dnf system-upgrade <subcommand> [options]

system-upgrade é usado para atualizar o sistema para uma nova versão. O comando baixa perimeiro os pacotes necessários na sessão ativa. Depois ele emite o subcomando reboot para reiniciar o sistema em ambiente “offline” mínimo para aplicar as atualizações. Essa é uma maneira recomendada para atualizar um sistema para uma nova versão principal. O sistema deve estar atualizado (na versão anterior), o que pode ser obtido com $ dnf --refresh upgrade. system-upgrade compartilha vários subcomandos com offline.
Subcomandos:

clean Idêntico ao subcomando de Offline
download Baixa todos os pacotes necessários para a atualização e verifica se eles podem ser instalados.
log Idêntico ao subcomando de Offline
reboot Idêntico ao subcomando de Offline

Opções:
.

–releasever= Obrigatório, define a versão para atualização. Marca a versão $releasever em todos os repositórios habilitados.
–no-downgrade Funciona como dnf update, não instaland pacotes da nova versão se forem mais antigos do que os já instalados. É o oposto do comportamento default, que sempre instala pacotes da nova versão, mesmo que mais antigos. Funciona como dnf update$ dnf distro-sync.
–number= Idêntico ao subcomando de Offline
–poweroff Idêntico ao subcomando de Offline

Exemplos de uso:

# atualizar sistema e carregar repositórios
$ dnf --refresh upgrade

# atualiza sistema e baixa pacotes da versão 40
$ dnf system-upgrade download --releasever 40

# atualiza e reinicializa sistema
$ dnf system-upgrade reboot

# mostrar logs da última tentativa de atualização
$ dnf system-upgrade log --number=-1

Comando upgrade

Uso: dnf upgrade [options] [<package-spec>|@|@...]

upgrade é usado para atualizar pacotes, grupos ou ambientes para a versão mais recente disponível.

Grupos e ambientes não possuem versões, portanto a atualização basicamente significa uma sincronização com a definição disponível atualmente. A atualização do grupo atualiza todos os pacotes desse grupo, e a atualização do ambiente atualiza todos os grupos contidos nesse ambiente.
Opções:

–minimal Atualiza pacotes para as versões mais baixas disponíveis que corrigem advsories do tipo correção de bugs, aprimoramento, segurança ou newpackage. Se uma opção de limitação de avisos for usada, atualiza os pacotes para as versões mais baixas que corrige avisos correspondentes às propriedades selecionadas
–allowerasing Permite remover pacotes instalados para resolver problemas de dependência.
–skip-unavailable Permite ignorar pacotes não possíveis de atualizar. Os demais pacotes serão atualizados.
–allow-downgrade Habilita o downgrade de dependências para resolver a operação solicitada.
–no-allow-downgrade Desativa o downgrade de dependências para resolver a operação solicitada.
–destdir= Define o diretório usado para baixar pacotes. O default é o diretório atual.
Automaticamente define a opção downloadonly.
–downloadonly Apenas baixa pacotes para transação.
–offline Armazena a transação para execução offline. Veja o comando Offline.
–advisories=ADVISORY_NAME,… Considera apenas o conteúdo contido em avisos com nome especificado.
Esta é uma opção de lista.
Os valores esperados são IDs consultivos, por exemplo. FEDORA-2201-123.
–advisory-severities=ADVISORY_SEVERITY,… Considera apenas o conteúdo contido em avisos com gravidade especificada.
Esta é uma opção de lista.
Os valores aceitos são: critical, important, moderate, low, none.
–bzs=BUGZILLA_ID,… Considera só o conteúdo em avisos que corrigem um ticket de determinado ID do Bugzilla.
Esta é uma opção de lista.
Os valores esperados são IDs numéricos, por exemplo. 123123.
–cves=CVE_ID,… Considera só conteúdo em avisos que corrigem um ticket de determinado ID CVE (Vulnerabilidades e Exposições Comuns).
Esta é uma opção de lista.
Os valores esperados são IDs de string no formato CVE, por exemplo: CVE-2201-0123.
–security Considera só o conteúdo nos avisos de segurança.
–bugfix Considera só o conteúdo nos avisos de correção de bugs.
–enhancement Considera só o conteúdo nos avisos de aprimoramento.
–newpackage Considera só o conteúdo nos avisos do newpackage.

Exemplos de uso:

# atualiza todos os pacotes instalados para a versão mais recente disponível.
$ dnf upgrade

# atualizar o pacote tito.
$ dnf upgrade tito

Comando versionlock

Uso: dnf versionlock <subcommand> <package-spec>...

versionlock recebe uma lista de nomes e versões para pacotes e exclui todas as demais versões desses pacotes. Dessa forma é possível proteger pacotes, impedindo que sejam atualizados para versões mais recentes. Alternativamente, o comando pode recer uma versão de pacote específica a ser excluída das atualizações, por exemplo, para ignorar uma versão específica de um pacote que tenha problemas conhecidos.

O plugin percorre as entradas do arquivo versionlock, excluindo pacotes cujo nome não corresponde às condições listadas. Isso é idêntico a usar dnf –exclude com o próprio nome do pacote (pois não se pode excluir pacotes instalados). No entanto as versões installed ou versionlocked ainda serão vistas como disponíveis pelo dnd, que ainda poderá reinstalar essas versões.

Nota: o comando versionlock não aplica nenhuma exclusão em operações não transacionais, como repoquery, list ou info.
Subcomandos:

add Adicione um versionlock em todos os pacotes disponíveis correspondentes à especificação. Isso significa que apenas pacotes e versões representados em package-spec ficam disponíveis para operações de transação.
exclude Adiciona uma exclusão (dentro do versionlock) para os pacotes correspondentes à especificação. Pacotes representados por package-spec serão excluídos das operações de transação.
clear Remove todas as entradas de versionlock.
delete Remove todas as entradas de versionlock correspondentes.
list Lista as entradas do versionlock.

Exemplos de uso:

# trava a versão do pacote acpi, se estiver instalado, para a versão atual.
# se acpi não estiver instalado, trava a versão do acpi para qualquer uma das versões disponíveis atualmente.
$ dnf versionlock add acpi

# mostra a configuração atual do versionlock.
$ dnf versionlock list

# remove todas as regras para o pacote acpi.
$ dnf versionlock delete acpi

# Exclui a versão iftop-1.2.3-7.fc38.
$ dnf versionlock exclude iftop-1.2.3-7.fc38

Formato de arquivo versionlock: versionlock é um arquivo TOML armazenado em /etc/dnf/versionlock.toml. Ele deve conter uma chave de versão (atualmente a versão suportada é 1.0). Ele também contém uma lista de entradas de bloqueio, em packages. Cada item da lista consiste no nome do pacote e uma lista de condições, que devem ser True para pacotes que correspondem às especificações (usando AND lógico). O conjunto das entradas são combinadas com a operação lógica OR.

Exemplos de arquivos versionlock podem ser vistos em Read the Docs: VersionLock.

Glossário

Especificação de padrões

Globs: globs são padrões que especificam um comjunto de nomes de arquivos usando caracteres “curingas” ou wildcard. Os padrões aceitos pelo dnf são os mesmos usados pela shell. Os seguintes padrões podem ser usados.

Definições:

* casa com qualquer número de caracteres, ou vazio.
? casa com um caracter único.
[xyz] casa com x, y ou z; qualquer um dos caracteres entre colchetes.
[a-z] casa qualquer um dos caracteres entre a até z, inclusive.
[!a-z] ou [^a-z] não casa com nenhum dos caracteres na faixa de a até z.
{ } colchetes não são suportados.

Exemplos:

*.txt casa com qualquer nome de arquivo que termina com .txt, como “texto.txt”, “aa.txt” ou “.txt”.
su*.css casa com “su.css”, “superman.css” ou “sucata.css”.
?asa.toml casa com qualquer nome de arquivo como “casa.toml”, “rasa.toml” ou “sasa.toml”.
??uga.pdf casa com “aluga.pdf”, “_ruga.pdf” mas não casa com “beluga.pdf”.
[a-m]luga.hlmt casa com “aluga.hlmt”, “gluga.hlmt”, “kluga.hlmt”, mas não com “pluga.hlmt”.
[!1-5]fix.jpg não casa com “3fix.jpg” nem “5fix.jpg”, mas casa com “7fix.jpg”.
[^1-5]fix.jpg o mesmo que acima.

Padrão NEVRA

Pacotes podem ser identificados exclusivamente pela string NEVRA, que consiste de 5 partes de informação:
Name | Epoch | Version | Release | Architecture

São eles: name do pacote (pode conter hifens), Epoch, um número, timestamp, nem sempre incluído, Version uma string, alfanumérica,Release da versão, Architecture, string definindo arquitetura do alvo.

Packages (Pacotes)

Muitos comandos usam o parâmetro <package-spec> para selecionar pacotes. Esse argumento é comparado com NEVRAs de pacotes, provides e file provides. Quando <package-spec> é um nome de pacote ou um provide, o usuário pode fornecer regras adicionais de restrição para corresponder aos argumentos. Comparações de versão podem usar os operadores lógicos =, >, <, >=, <= como, por exemplo, <package-spec>>= <version>, onde o argumento <version> está no formato [EPOCH:]VERSION[-RELEASE] conforme especificado acima.

<package-file-spec> é similar a <package-spec>, exceto que provides matching não é executado. Portanto, <package-file-spec> é correspondido somente com NEVRAs e file provides. <package-name-spec> é correspondido somente com NEVRAs.

Bibliografia

DNF5, Resumo Geral

Junto com essas notas as seguintes páginas podem ser consultadas:

Descrição geral do comando DNF5


Uso:
dnf [Opções Globais] <Comando> ...

Nota: usamos aqui dnf como um aliás para dnf5.

Comandos de gerenciamento de software

Comando Descrição
install Instalar software
upgrade Atualizar software
remove Remover (desinstalar) software
distro-sync Atualizar ou fazer downgrade do software instalado para as últimas versões disponíveis
downgrade Fazer downgrade do software
reinstall Reinstalar software
debuginfo-install Instalar pacotes debuginfo
swap Remover software e instalar outro na mesma transação
mark Alterar o motivo de um pacote instalado
autoremove Remover todos os pacotes instalados como dependências e agora desnecessários
provides Encontre qual pacote fornece o valor fornecido
replay Refazer uma transação anteriormente armazenada em um diretório
check-upgrade Verificar se há atualizações disponíveis para pacotes
check Verifique se há problemas no packagedb

Comandos de consulta

Comando Descrição
leaves Lista grupos de pacotes instalados não necessários para outros pacotes instalados
repoquery Pesquise por pacotes que correspondam a vários critérios
search Pesquise por software que corresponda a todas as strings especificadas
list Lista pacotes dependendo da relação dos pacotes com o sistema
info Lista pacotes dependendo da relação dos pacotes com o sistema

Subcomandos

Subcomando Descrição
group Gerencia grupos de comps
environment Gerencia ambientes de comps
module Gerencia módulos
history Gerencia histórico de transações
repo Gerencia repositórios
advisory Gerencia avisos
versionlock Gerencia configuração de versionlock
system-upgrade Prepara o sistema para atualização para uma nova versão
offline-distrosync Armazena uma transação de distro-sync para ser executada offline
offline-upgrade Armazena uma transação de atualização para ser executada offline
offline Gerencia transações offline
config-manager Gerencia configuração

Outros comandos

Comando Descrição
clean Remove ou expira dados em cache
download Baixa, sem instalar, o software para o diretório atual
makecache Gera o cache de metadados
builddep Instala dependências de compilação para pacote ou arquivo de especificação
changelog Mostra os changelogs do pacote
copr Gera repositórios Copr (complementos fornecidos por usuários/comunidade/terceiros)
needs-restarting Determina se os serviços do sistema ou systemd precisam ser reiniciados
repoclosure Imprime a lista de dependências não resolvidas para repositórios
build-dep Alias ​​de compatibilidade para ‘builddep’

Opções globais:

Comando Descrição
-h, –help Exibe ajuda
–config=CONFIG_FILE_PATH Localiza o arquivo de configuração
-q, –quiet Junto com comando não interativo mostra só o conteúdo relevante. Suprime notificações sobre o estado atual ou ações do dnf5.
-C, –cacheonly Executa inteiramente com o cache do sistema, mesmo se estiver expirado; não atualiza o cache
–refresh Força a atualização de metadados antes de executar o comando.
–repofrompath=REPO_ID,REPO_PATH cria repositório adicional usando id e caminho
–setopt=[REPO_ID.]OPTION=VALUE define opções arbitrárias de configuração e repositório
–setvar=VAR_NAME=VALUE define variável arbitrária
-y, –assumeyes responde automaticamente sim para todas as perguntas
–assumeno responde automaticamente não para todas as perguntas
–best tenta as melhores versões de pacote disponíveis em transações
–no-best não limita a transação ao melhor candidato
–no-docs Não instala arquivos marcados como documentação (o que inclui páginas de manual e documentos texinfo)
-x pacote,…, –exclude=pacote,… exclui pacotes por nome ou glob
–enable-repo=REPO_ID,… Habilita repositórios adicionais. Opção de lista. Suporta globs, pode ser especificado várias vezes.
–disable-repo=REPO_ID,… Desabilita repositórios. Opção de lista. Suporta globs, pode ser especificado várias vezes.
–repo=REPO_ID,… Habilita apenas repositórios específicos. Opção de lista. Suporta globs, pode ser especificado várias vezes.
–no-gpgchecks desabilita a verificação de assinatura gpg (se a política RPM permitir)
–no-plugins Desabilita todos os plugins libdnf5
–enable-plugin=PLUGIN_NAME,… Habilita plugins libdnf5 por nome. Opção de lista. Suporta globs, pode ser especificado várias vezes.
–disable-plugin=PLUGIN_NAME,… Desabilita plugins libdnf5 por nome. Opção de lista. Suporta globs, pode ser especificado várias vezes.
–comment=COMMENT adiciona um comentário à transação
–installroot=ABSOLUTE_PATH define raiz de instalação
–use-host-config usa configuração, reposdir e vars do sistema host em vez do installroot
–releasever=RELEASEVER substitui o valor de $releasever em arquivos de configuração e repositório
–show-new-leaves Mostra pacotes leaf recém-instalados e pacotes que se tornaram leaves após uma transação.
–debugsolver Despeja resultados detalhados de resolução em arquivos
–dump-main-config Imprime valores de configuração principais no stdout
–dump-repo-config=REPO_ID,… Imprime valores de configuração do repositório no stdout. Opção de lista. Suporta globs
–dump-variables Imprime valores de variáveis ​​no stdout
–version Mostra a versão DNF5 e sai
–forcearch=FORCEARCH Força o uso de uma arquitetura diferente.

Aliases

A primeira coluna é uma lista de aliases de compatibilidade com o dnf4. A segunda coluna mostra aliases de opções:

Alias Substitui
check-update check-upgrade
dg downgrade
dsync distro-sync
grp group
if info
in install
ls list
mc makecache
rei reinstall
repoinfo repoinfo
repolist repolist
rm remove
rq repoquery
se search
up upgrade
update upgrade
updateinfo advisory
upgrade-minimal upgrade–minimal
Alias Substitui
-c CONFIG_FILE_PATH –config
–nobest –no-best
–nodocs –no-docs
–enablerepo=REPO_ID,… –enable-repo
–disablerepo=REPO_ID,… disable–repo
–repoid=REPO_ID,… –repo
–nogpgcheck –no-gpgchecks
–noplugins –no-plugins
–enableplugin=PLUGIN_NAME,… –enable-plugin
–disableplugin=PLUGIN_NAME,… –disable-plugin

Bibliografia

Flet: CircleAvatar, CupertinoActivityIndicator, Icon


Controle CircleAvatar

O controle CircleAvatar desenha um círculo que pode conter imagens, ícones ou texto. Geralmente é usado para representar o avatar de um usuário. Um texto alternativo pode ser usado para exibição caso a imagem declarada não esteja acessível.

Propriedades e evento de CircleAvatar

As seguintes propriedades e evento existem no controle CircleAvatar:

Descrição
background_image_src recurso de imagem (local ou URL) a ser renderizado no fundo do círculo. Se essa imagem é alterada uma animação será mostrada na troca de imagens. Alterar a imagem de fundo fará com que o avatar anime para a nova imagem. Essa imagem serve como fallback para foreground_image_src. Caso as iniciais do usuário devem ser exibidas (ou qualquer outro texto curto), informe a imagem na propriedade content.
bgcolor cor de fundo do círculo. Alteração na cor provocará uma animação no avatar para a nova cor.
color cor do texto padrão. Default O padrão é a cor do tema de texto primário se a cor de fundo não for especificada.
content normalmente, um controle de texto. Para apresentar uma imagem em CircleAvatar use background_image_src.
foreground_image_src A fonte (arquivo de ativo local ou URL) da imagem de primeiro plano no círculo. Normalmente usada como imagem de perfil. Para fallback, use background_image_src.
max_radius O tamanho máximo do avatar, expresso como o raio (metade do diâmetro). Se maxRadius for especificado, o raio também não deve ser especificado. O padrão é “infinito”.
min_radius O tamanho mínimo do avatar, expresso como o raio (metade do diâmetro). Se minRadius for especificado, o raio não deve ser especificado também. O padrão é zero.
radius O tamanho do avatar, expresso como o raio (metade do diâmetro). Se radius for especificado, nem minRadius nem maxRadius podem ser especificados.
tooltip O texto exibido ao passar o mouse sobre o botão.
Evento Descrição
on_image_error dispara quando ocorre um erro ao carregar imagens em background_image_src ou foreground_image_src.
Os evento tem a propriedade e.data que contém uma string com valor “background” ou “foreground”, indicando a origem do erro.

Exemplo de uso do CircleAvatar

import flet as ft

def main(page):
    page.bgcolor=ft.colors.WHITE
    foto="https://phylos.net/wp-content/uploads/2017/12/GuilhermeRoundPequeno.png"
    ico=ft.Icon(ft.icons.BEDROOM_BABY)

    a1 = ft.CircleAvatar(foreground_image_src=foto, content=ft.Text("autor"))

    a2 = ft.Stack([a1, ft.CircleAvatar(bgcolor="green", radius=7)], width=40, height=40)

    a3 = ft.CircleAvatar(content=ico, bgcolor="red", color="black")

    a4 = ft.CircleAvatar(content=ico, color="red", bgcolor="black")

    a5 = ft.CircleAvatar(content=ft.Text("@", size=20))

    page.add(ft.Row([a1, a2, a3, a4, a5]))

ft.app(target=main)
Figura 1: resultado do código de CircleAvatar

Os controles CircleAvatar nesse código são:

  • a1: um avatar comum com imagem de fundo,
  • a2: um avatar com círculo de status,
  • a3: um avatar avatar com ícon, e cores customizadas,
  • a4: um avatar avatar com ícon, e cores customizadas invertidas, e
  • a5: um avatar com imagem de fundo e texto fallback.

Controle CupertinoActivityIndicator

O controle CupertinoActivityIndicator é uma imagem indicadora de atividade no estilo Cupertino (iOS) que pode ou não ser animado. Se animado a imagem gira no sentido horário.

Propriedades de CupertinoActivityIndicator

Descrição
animating booleano, default=True. Se o indicador deve ser animado.
color a cor do indicator
radius raio do indicador de atividade (tamanho).

Exemplo de uso do CupertinoActivityIndicator

import flet as ft

def main(page):
    page.bgcolor=ft.colors.WHITE

    act0=ft.CupertinoActivityIndicator(radius=20, color=ft.colors.GREEN, animating=True)
    act1=ft.CupertinoActivityIndicator(radius=50, color=ft.colors.BLUE, animating=True)
    act2=ft.CupertinoActivityIndicator(radius=30, color=ft.colors.RED)

    page.add(ft.Row([act0, act1, act2]))

ft.app(target=main)
Figura 2: resultado do código de ActivityIndicator

Controle Icon

O controle Icon desenha um ícone no estilo Material na página do aplicativo.

Uma página interativa na web pode ser usada para buscar nomes dos ícones desejados, em Flet: Icons Browser.

Propriedades de Icon

Propriedade Descrição
color cor do ícone.
name nome do ícone.
semantics_label nome semântico do ícone. Não é exibido na página mas pode ser acionado em modos de acessibilidade.
size tamanho do ícone. Defaul = 24.
tooltip texto da “dica”, exibido com a passar do mouse (hovering).

Exemplo de uso do Controle Icon

import flet as ft

def main(page: ft.Page):
    page.theme_mode = ft.ThemeMode.LIGHT

    def cor_original():
        ico1.color=ft.colors.PINK
        ico2.color=ft.colors.YELLOW
        ico3.color=ft.colors.GREEN
        ico4.color=ft.colors.BLUE

    def mudar_cor(e):
        if ico1.color==ft.colors.PINK:
            arr_Icons=page.controls[0].controls
            for i in arr_Icons:
                i.color=ft.colors.GREY
        else:
            cor_original()
        page.update()

    def tamanho(e):
        arr_Icons=page.controls[0].controls
        for i in arr_Icons:
            i.size+=5
        page.update()

    ico1=ft.Icon(name=ft.icons.SD_CARD, size=15)
    ico2=ft.Icon(name="sd_card", size=15)
    ico3=ft.Icon(name=ft.icons.ANCHOR, size=30)
    ico4=ft.Icon(name=ft.icons.ELECTRIC_CAR, size=50)
    cor_original()
    bt_cor=ft.ElevatedButton("Mudar Cor", icon="arrow", on_click=mudar_cor, width=150)
    bt_tamanho=ft.ElevatedButton("Tamanho", icon="arrow", on_click=tamanho, width=150)

    page.add(ft.Row([ico1, ico2, ico3, ico4]), ft.Row([bt_cor, bt_tamanho]))

ft.app(target=main)
Figura 3: resultado do código de exemplo de Icon

A figura 3 mostra o resultado do código. A Figura 3-A é o estado inicial do aplicativo. Figura 3-B é o estado após 5 cliques no botão “Tamanho”. O  botão “Muda Cor” alterna entre as cores originais e um tom de cinza, para todos os ícones.

Um comentário pode ser útil aqui: como a propriedade de cores dos ícones é usada mais de uma vez, é interessante atribuir essas propriedades em um mesmo bloco de código, o que é feito na função cor_original().

Percorrer todos os ícones para mudar de tamanho ou atribuir a cor cinza foi feita da seguinte forma: foram capturados todos os ícones em um array arr_Icons. Observe que:

  • page.controls[] é uma lista com 2 linhas,
  • page.controls[0] é a primeira linha da lista,
  • page.controls[0].controls é lista de ícones existentes na 1a linha,
  • page.controls[0].controls[i] é cada um dos ícones, (i=0,1, 2, 3),
  • page.controls[0].controls[i].size é o tamanho de cada ícone, e
  • page.controls[0].controls[i].color é a cor de cada ícone.