Como instalar a biblioteca libwebp

O que é libwebp?

Libwebp é uma biblioteca de software de código aberto desenvolvida pelo Google para codificar e decodificar imagens no formato WebP.

WebP, também criado pelo Google, é um formato de imagem que oferece alta qualidade com tamanhos de arquivo menores do que os formatos tradicionais como JPEG e PNG.

Isso significa que as imagens WebP carregam mais rapidamente, o que pode melhorar o desempenho e a experiência do usuário em sites e aplicativos.

A libwebp fornece uma maneira fácil de integrar a funcionalidade WebP em seus próprios programas.

Alguns dos recursos da libwebp incluem:

  • Codificação e decodificação de imagens WebP.

  • Suporte para imagens com e sem perdas.

  • Suporte para transparência.

  • Controle preciso sobre a qualidade da imagem.

  • APIs fáceis de usar.


Instalação

Linux

Arch Linux
sudo pacman -S \
libwebp
Fedora
sudo dnf install \
libwebp
Ubuntu
sudo apt install \
libwebp

macOS

Homebrew
brew install \
webp

https://formulae.brew.sh/formula/webp.


Utilitário pré compilado

O Google fornece o utilitários pré compilados para os seguintes sistemas operacionais:

  • Microsoft Windows (x64).

  • Linux (aarch64).

  • Linux (x86-64).

  • macOS (arm64).

  • macOS (x86-64).

Para baixar o utilitário acesse:

Após realizar o download descompacte o arquivo que foi baixado em um diretório onde o mesmo não será removido.

Em seguida adicione a pasta bin ao PATH do sistema operacional.

Linux

Edite o arquivo *.bashrc e adicione o caminho até a basta bin:

export PATH="caminho/nome-da-pasta/bin:$PATH"

Algumas distribuições Linux já possuem as pastas $HOME/.local/bin e $HOME/bin mapeadas na variável PATH.

Neste caso basta copiar os binário da pasta bin para uma das pastas bin do sistema operacional.

Se houver a necessidade de mapear esses diretórios na variável PATH do sistema operacional, os seguintes comandos podem ser utilizados:

echo 'export PATH="$HOME/bin:$PATH"' \
>> ~/.bashrc

ou

echo 'export PATH="$HOME/.local/bin:$PATH"' \
>> ~/.bashrc

Após adicionar é necessário executar:

source ~/.bashrc

macOS

Adicione o caminho até a pasta bin no arquivo .bash_profile:

export PATH="$PATH:caminho/nome-da-pasta/bin"

Ou adicione um arquivo com o caminho no diretório paths.d:

sudo -s 'echo "caminho/nome-da-pasta/bin" > /etc/paths.d/libwebp'

Microsoft Windows

Abra o aplicativo Variáveis de Ambiente:

Advanced system settings -> Environment variables -> Path -> Edit.

E adicione o caminho até a pasta bin.

Como fazer o deploy do Python Sphinx no Github pages

Hoje veremos como utilizar o GitHub Actions para automatizar o processo de deploy do Python Sphinx no Github Pages.

O que é o Sphinx?

O Sphinx é uma poderosa ferramenta de documentação que facilita a criação de documentação para projetos Python.

Ele é frequentemente usado para criar documentação de código-fonte, manuais de usuário, guias de API e outros tipos de documentação.

O Sphinx utiliza arquivos de marcação simples, como reStructuredText, para escrever a documentação e suporta a geração de saída em vários formatos, como HTML, PDF, ePub e man pages.

Ele também oferece recursos avançados, como indexação automática, geração de índices, suporte para diagramas e integração com ferramentas de construção como o make.

Essas características fazem do Sphinx uma escolha popular para projetos Python que valorizam uma documentação completa e bem formatada.

Github Pages

O GitHub Pages é um serviço oferecido pelo GitHub que permite hospedar websites estáticos diretamente a partir de um repositório do GitHub.

Ele é comumente usado para hospedar páginas de documentação, blogs pessoais, páginas de projetos e sites simples.

O GitHub Pages suporta sites estáticos gerados a partir de arquivos HTML, CSS e JavaScript, bem como frameworks estáticos como Jekyll, Hugo, Sphinx e Gatsby.

Criando o arquivo de deploy

No repositório crie um arquivo pages.yaml em .github/workflows.

⚠️ O arquivo pode ter o nome que você desejar.

Dentro do arquivo pages.yaml será utilizado o seguinte código:

# Fluxo de deploy para documentação com Python e Sphinx no Github pages.
name: Deploy Sphinx content to Pages.

on:
  push:
    branches: ['main']
  workflow_dispatch:

permissions:
  contents: read
  pages: write
  id-token: write

concurrency:
  group: 'pages'
  cancel-in-progress: true

jobs:
  deploy:
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    runs-on: ubuntu-latest
    steps:
      - name: Checkout 💾
        uses: actions/checkout@v4

      - name: Setup Pages
        uses: actions/configure-pages@v5

      - name: Install Python 🐍
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'
          cache: 'pip'

      - name: Install requirements 🔨
        working-directory: .
        run: pip install -r requirements-docs.txt

      - name: Sphinx make dirhtml 🌎
        working-directory: ./docs
        run: make dirhtml

      - name: Upload artifact 🚀
        uses: actions/upload-pages-artifact@v3
        with:
          path: './docs/build/dirhtml'

      - name: Deploy to GitHub Pages 💻
        id: deployment
        uses: actions/deploy-pages@v4

Ao final do processo de deploy acesse a URL do repositório (https://usuário.github.io/repositório/) para ter acesso a sua documentação/site no Github Pages.

Também é possível executar essa Github Action através da interface web do Github, para isso basta clicar na aba Actions.

Se o deploy não ocorrer vefifique as configurações do repositório em settings -> pages.


Conclusão

O GitHub Actions e o Github Pages são ferramentas poderosas para automatizar e personalizar seu fluxo de trabalho de desenvolvimento, ajudando a melhorar a produtividade e a consistência do seu projeto.

Como fazer o deploy de um aplicativo Qt com Github Actions

Como fazer o deploy de um aplicativo Qt com Github Actions

Hoje veremos como utilizar o GitHub Actions com Nuitka para automatizar o processo de deploy de um aplicativo que utiliza a linguagem de programação Python e o binding PySide6.

O que é o Github Actions?

O GitHub Actions é um recurso do GitHub que permite automatizar tarefas dentro do seu fluxo de trabalho de desenvolvimento de software.

Com o GitHub Actions, você pode criar fluxos de trabalho customizados para automatizar a compilação, teste, implantação e outras etapas do ciclo de vida do desenvolvimento de software.

Os fluxos de trabalho do GitHub Actions são definidos em arquivos YAML (***.yaml**) armazenados no diretório **.github/workflows** do seu repositório.

Esses arquivos descrevem as ações a serem executadas, incluindo as condições sob as quais devem ser acionadas e quaisquer parâmetros necessários.

As ações do GitHub Actions são unidades de trabalho individuais que podem ser combinadas para criar fluxos de trabalho complexos.

Existem ações disponíveis na GitHub Marketplace que podem ser usadas para uma variedade de tarefas, como compilar código, executar testes, implantar aplicativos e notificar equipes sobre o progresso do desenvolvimento.

Nuitka

Nuitka é um compilador Python de código aberto que traduz código Python para C++ ou código C otimizado, permitindo que ele seja executado mais rapidamente do que se fosse interpretado diretamente pelo interpretador Python padrão.

Ele funciona analisando o código Python e o traduzindo para código C ou C++, que é então compilado em código de máquina nativo. Isso pode resultar em melhorias significativas de desempenho em determinadas situações, especialmente em código Python que é intensivo em CPU.

Criando o arquivo de deploy

No repositório crie um arquivo deploy.yaml em .github/workflows.

⚠️ O arquivo pode ter o nome que você desejar.

Dentro do arquivo será utilizado o seguinte código:

# Fluxo de deploy para um aplicativo Qt (PySide) com Nuitka.
name: Deploying PySide6 with Nuitka ⚙️.
on:
  # Arquivo será executado sempre que houver um push para a branch main.
  push:
    branches: ['main']
  # Esta opção permite executar a ação de forma manual na interface web do Github.
  workflow_dispatch:

# Definindo as permissões do GITHUB_TOKEN.
permissions:
  contents: read
  pages: write
  id-token: write

# Permite que a implantação seja simultânea.
concurrency:
  group: 'deploy'
  cancel-in-progress: true

jobs:
  build:
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: '${{ matrix.os }}'
    steps:
      - name: Check out repository 💾.
        uses: actions/checkout@v4

      - name: Install Python 🐍.
        uses: actions/setup-python@v5
        with:
            python-version: '3.11'
            architecture: 'x64'
            cache: 'pip'
            cache-dependency-path: |
              **/requirements*.txt

      - name: Install requirements 🔨.
        working-directory: .
        run: python -m pip install --upgrade pip && pip install -r requirements.txt

      - name: Install and configure Nuitka 🛠️.
        uses: Nuitka/Nuitka-Action@main
        with:
          nuitka-version: main
          script-name: caminho/até/o/script.py
          enable-plugins: pyside6
          quiet: true
          standalone: true
          disable-console: true
          macos-create-app-bundle: true
          output-file: nome-do-aplicativo
          linux-icon: caminho/até/ícone.ico
          windows-icon-from-ico: caminho/até/ícone.ico
          macos-app-icon: caminho/até/ícone.icns
          macos-app-name: nome-do-aplicativo

      - name: Upload artifact (onefile) 🚀.
        uses: actions/upload-artifact@v4
        with:
          name: '${{ runner.os }}-build'
          path: |
            build/app.dist
            build/*.exe
            build/*.bin
            build/*.app/**/*

⚠️ Lembre-se de modificar as variáveis conforme as suas necessidades.

O arquivo de deploy considera sempre a raiz do projeto como diretório padrão, neste caso adicione o caminho relativo até os ícones.

Essa Github Action será executada sempre que houver um push para a branch main do repositório.

Também é possível executar essa Github Action através da interface web do Github, para isso basta clicar na aba Actions.

Ao final do processo é possível verifica os executáveis que foram gerados para cada um dos sistema operacionais e fazer o download dos mesmos.

Conclusão

O GitHub Actions é uma ferramenta poderosa para automatizar e personalizar seu fluxo de trabalho de desenvolvimento, ajudando a melhorar a produtividade e a consistência do seu projeto.

Como criar um aplicativo Flutter com Python e o framework Flet

No mundo dinâmico do desenvolvimento de aplicativos, a busca por ferramentas eficientes e inovadoras é constante.

Entre as opções que se destacam, o Flet surge como uma alternativa promissora, especialmente para aqueles que desejam criar aplicativos multiplataforma utilizando a linguagem Python.

O que é o Flet?

O Flet se apresenta como um framework de desenvolvimento de interfaces de usuário (UI) para Flutter, possibilitando a criação de aplicativos multiplataforma com a simplicidade e flexibilidade da linguagem Python.

Ele funciona como uma camada abstrata sobre o Flutter, traduzindo o código Python em widgets Flutter nativos, permitindo que você desenvolva aplicativos para diversas plataformas, como:

  • Android: Crie aplicativos mobile robustos para o sistema operacional mais popular do mundo.

  • iOS: Dê vida às suas ideias nos dispositivos da Apple com alta qualidade e performance.

  • Web: Expanda o alcance dos seus aplicativos para a web, acessíveis por qualquer navegador.

  • Desktop: Crie interfaces desktop elegantes e funcionais para Windows, macOS e Linux.


Quais as principais vantagens do Flet?

O Flet se destaca por oferecer uma série de vantagens que o tornam uma ferramenta valiosa para desenvolvedores:

  • Simplicidade: A sintaxe Python do Flet é clara, intuitiva e fácil de aprender, mesmo para aqueles sem experiência anterior com Flutter ou desenvolvimento mobile.

  • Produtividade: O Flet permite um desenvolvimento rápido e eficiente, reduzindo significativamente o tempo necessário para criar aplicativos completos.

  • Multiplataforma: Com apenas uma base de código Python, você gera aplicativos para diversas plataformas, otimizando seu tempo e recursos.

  • Flexibilidade: O Flet oferece total liberdade para personalizar seus aplicativos, utilizando widgets prontos ou criando seus próprios componentes.

  • Comunidade: Uma comunidade crescente e ativa de desenvolvedores Flet garante suporte mútuo e colaboração em projetos.


Desvantagens e Considerações

Embora o Flet apresente diversos benefícios, é importante considerar alguns pontos antes de utilizá-lo em seus projetos:

  • Maturidade: O Flet é uma ferramenta relativamente nova, ainda em desenvolvimento, o que significa que pode haver menos recursos e documentação disponíveis em comparação com frameworks mais maduros.

  • Desempenho: Em alguns casos específicos, o desempenho de aplicativos Flet pode ser ligeiramente inferior ao de aplicativos Flutter nativos desenvolvidos diretamente na linguagem Dart.

  • Comunidade: Apesar do crescimento, a comunidade Flet ainda é menor em comparação com outras comunidades de desenvolvimento.


Começando com o Flet

Para dar os primeiros passos com o Flet, precisamos criar um ambiente virtual do Python.

Você pode utilizar ferramentas como PDM, Poetry, Pipenv ou mesmo o módulo venv que é nativos na linguagem de Programação Python.

Criando o ambiente virtual com venv

Para exemplificar vamos utilizar o módulo venv.

Microsoft Windows
mkdir myapp
cd myapp
python -m venv .venv
.venv\Scripts\activate
Linux e macOS
mkdir myapp
cd myapp
python3 -m venv .venv
source .venv/bin/activate

Após criar e ativar o ambiente virtual podemos realizar a instalação do framework Flet como comando:

pip install flet

Criando um aplicativo

Para um novo aplicativo o framework Flet fornece o comando:

flet create .

Para testar o aplicativo que acaba de ser criado:

flet run

Para exexutar o aplicativo no navegador:

flet run --web

Publicando o aplicativo Flet em múltiplas plataformas

Para fazer o build do aplicativo Flet é necessário ter o Flutter instalado no computador.

Como instalar a linguagem de programação Flutter

macOS
brew install --cask flutter
Linux
Arch Linux

Site oficial da distribuição Linux Arch Linux.

sudo pacman -S \
flutter
Fedora

Site oficial da distribuição Linux Fedora.

sudo dnf install \
flutter

Site ofical

O site ofical do Flutter fornece instruções de como realizar a instalação em outros sistema operacionais:

Após realizar a instalação e configuração do Flutter acesse a pasta do projeto e execute o comando:

flet build nome-da-plataforma

Até o momento as plataformas disponíveis são:

  • macos.

  • linux.

  • windows.

  • web.

  • apk.

  • aab.

  • ipa.

⚠️ Não há suporte a cross compiler.

⚠️ No macOS o Xcode deve estar instalado.

Como criar um aplicativo com Python e GTK no ChromeOS

Hoje veremos como preparar o ambiente de desenvolvimento no Chromebook para a criação de aplicativos com a linguagem de programação Python (PyGObject) e o toolkit gráfico GTK no Chromebook (ChromeOS) 🤩.

OBS: Antes de mais nada, é necessário que o ambiente Linux esteja configurado no ChromeOS.

Dependendo da versão do Debian algumas configurações adicionais se fazem necessárias.

A seguir veremos com mais detalhes esses procedimentos.


Debian Bookworm

A distribuição Linux Debian Bookworm possui os pacotes do GTK 4 nos seus repositórios estáveis.

Abra o terminal e digite o seguinte comando:

sudo apt -t sid install \
python3-full \
python3-dev \
python3-gi \
python3-gi-cairo \
libcairo2-dev \
libgirepository1.0-dev \
gir1.2-gtk-4.0 \
libgtk-4-dev \
libadwaita-1-dev

Assim que a instalação estiver concluída a linguagem de programação Python no ChromeOS, o binding PyGObject e as bibliotecas gráficas GTK no ChromeOS estarão instalados.


Debian Buster e Bullseye

Nessas versões do Debian os pacotes do GTK 4 não estão disponíveis nos repositórios estáveis e se faz necessária a configuração do repositório sid.

Debian sid

Para adicionar o repositório sid é necessário editar o arquivo **sources.list**.

Para editar o arquivo, abra o terminal e utilize um editor de texto como o vi ou vim, todavia se você não possui experiência com esses editores instale o nano:

sudo apt install nano

Após a instalação digite no terminal:

sudo nano /etc/apt/sources.list

Agora, vamos adicionar o repositório testing (sid) no arquivo sources.list:

# Generated by distrobuilder
deb https://deb.debian.org/debian bullseye main
deb https://deb.debian.org/debian bullseye-updates main
deb https://deb.debian.org/debian-security/ bullseye-security main

deb http://http.us.debian.org/debian sid main non-free contrib

⚠️ NÃO EXECUTE sudo apt update OU MESMO sudo apt upgrade!

Agora precisamos criar/editar o arquivo preferences.

Se essa configuração não for feita, o sistema tentará atualizar todos os pacotes para as últimas versões e isso irá gerar diversos pacotes quebrados.

No terminal execute:

sudo nano /etc/apt/preferences

Dentro deste arquivo digite o seguinte código:

Package: *
Pin: release a=stable
Pin-Priority: 700

Package: *
Pin: release a=testing
Pin-Priority: 650

Package: *
Pin: release a=unstable
Pin-Priority: 600

Salve o arquivo e agora podemos atualizar os repositórios:

sudo apt update

Assim que a atualização dos repositórios for finalizada execute o seguinte comando para instalar os pacotes necessários:

sudo apt -t sid install \
python3-full \
python3-dev \
python3-gi \
python3-gi-cairo \
libcairo2-dev \
libgirepository1.0-dev \
gir1.2-gtk-4.0 \
libgtk-4-dev \
libadwaita-1-dev

Após a instalação a linguagem de programação Python no ChromeOS, o tookit GTK 4 e o binding PyGObject estarão instalados e prontos para uso 🚀.


Ambientes virtuais

Se você ainda não utiliza, este é um bom momento para testar algumas opções:

Criando o ambiente virtual

Acesse a pasta raiz do seu projeto, abra um terminal, em seguida execute o comando:

python3 -m venv venv

Para criar o ambiente virtual utilizando uma versão específica da linguagem de programação Python no ChromeOS pode ser utilizado comando:

python3.X -m venv venv

⚠️ Substitua o X pela versão da linguagem de programação Python no ChromeOS que deseja utilizar.

⚠️ A versão desejada deve estar instalada no sistema operacional!

Ativando o ambiente virtual

Após ser criado o ambiente virtual precisa ser ativado, caso contrário a instalação dos pacotes será realizada na instalação local da linguagem de programação Python no ChromeOS e não no ambiente virtual.

Para ativar o ambiente virtual:

source venv/bin/activate

Instalando o binding

Com o ambiente virtual ativo, vamos começar atualizando o gerenciador de pacotes do Python (pip) com o comando:

python -m pip install \
--upgrade pip

Em seguida vamos instalar o binding PyGObject e a biblioteca PyGObject-stubs com o comando:

pip install \
pygobject \
PyGObject-stubs

Perfeito! Com isso podemos iniciar o desenvolvimento em um ambiente onde as dependências estão isoladas 😃.


Testando

A forma mais simples de testar a comunicação entre a linguagem de programação Python no ChromeOS e o toolkit gráfico GTK é executar no terminal o comando:

python3 -c "import gi"

⚠️ Lembre-se que o comando deve ser executado com o ambiente virtual ativo!

Se ao executar o comando nenhum erro for retornado, a instalação e configuração do ambiente Python e GTK no Chromebook estão corretas 👍👋👋.


Código de exemplo

Para testar a configuração no seu editor de texto ou IDE utilize o seguinte código de exemplo:

# -*- coding: utf-8 -*-
"""Python e GTK: PyGObject Gtk.ApplicationWindow()."""

import gi

gi.require_version(namespace='Gtk', version='4.0')
gi.require_version(namespace='Adw', version='1')

from gi.repository import Adw, Gio, Gtk

Adw.init()


class ExampleWindow(Gtk.ApplicationWindow):

    def __init__(self, **kwargs):
        super().__init__(**kwargs)

        self.set_title(title='Python - PyGObjet - GTK:')
        self.set_default_size(width=int(1366 / 2), height=int(768 / 2))
        self.set_size_request(width=int(1366 / 2), height=int(768 / 2))

        headerbar = Gtk.HeaderBar.new()
        self.set_titlebar(titlebar=headerbar)

        menu_button_model = Gio.Menu()
        menu_button_model.append('Preferências', 'app.preferences')

        menu_button = Gtk.MenuButton.new()
        menu_button.set_icon_name(icon_name='open-menu-symbolic')
        menu_button.set_menu_model(menu_model=menu_button_model)
        headerbar.pack_end(child=menu_button)

        # O seu código aqui:
        # ...


class ExampleApplication(Adw.Application):

    def __init__(self):
        super().__init__(application_id='br.com.justcode.Example',
                         flags=Gio.ApplicationFlags.FLAGS_NONE)

        self.create_action('quit', self.exit_app, ['<primary>q'])
        self.create_action('preferences', self.on_preferences_action)

    def do_activate(self):
        win = self.props.active_window
        if not win:
            win = ExampleWindow(application=self)
        win.present()

    def do_startup(self):
        Gtk.Application.do_startup(self)

    def do_shutdown(self):
        Gtk.Application.do_shutdown(self)

    def on_preferences_action(self, action, param):
        print('Ação app.preferences foi ativa.')

    def exit_app(self, action, param):
        self.quit()

    def create_action(self, name, callback, shortcuts=None):
        action = Gio.SimpleAction.new(name, None)
        action.connect('activate', callback)
        self.add_action(action)
        if shortcuts:
            self.set_accels_for_action(f'app.{name}', shortcuts)


if __name__ == '__main__':
    import sys

    app = ExampleApplication()
    app.run(sys.argv)

Como criar um aplicativo com Python e GTK no Windows WSL 2

Hoje, aprenderemos a preparar o ambiente de desenvolvimento para criar aplicativos com a linguagem de programação Python (PyGObject) e o toolkit gráfico GTK no WSL 2 (Windows Subsystem for Linux) do Microsoft Windows.

Através do WSLg (Windows Subsystem for Linux GUI), é possível iniciar e interagir com aplicativos gráficos do Linux usando um ambiente de desktop nativo do Windows.

O WSLg utiliza o protocolo de servidor de exibição Wayland e um compositor de sistema do Windows para renderizar os aplicativos GUI do Linux. Ele também aproveita a aceleração da GPU para melhorar o desempenho gráfico.

⚠️ Para utilizar o WSLg, é necessário possuir o Microsoft Windows 10 Build 19044 ou superior.

Instalando o WSL

A instalação do WSL 2 é bastante simples.

Abra o PowerShell ou CMD como administrador e execute o comando:

wsl --install

Assim que o comando finalizar a instalação de todos os componentes do WSL 2 e da distribuição Linux Ubuntu, reinicie o computador.

Dependências

Localize a distribuição Linux Ubuntu no menu iniciar do Microsoft Windows.

⚠️ Na primeira execução, será solicitada a criação de um usuário e senha.

Assim que o Ubuntu estiver inicializado, digite no terminal:

sudo apt update && sudo apt dist-upgrade

Após a conclusão das atualizações, instale a linguagem de programação Python e as bibliotecas do GTK com o comando:

sudo apt install \
build-essential \
meson \
ninja-build \
python3-full \
python3-dev \
python3-pip \
python3-dev \
python3-gi \
python3-gi-cairo \
libcairo2-dev \
libgirepository1.0-dev \
gir1.2-gtk-4.0 \
libgtk-4-dev \
libadwaita-1-dev \
gtk-4-examples

Ao finalizar a instalação dos pacotes, a linguagem de programação Python, o binding PyGObject e as bibliotecas do GTK estarão instalados e prontos para uso 🚀.

Visual Studio Code

O Visual Studio Code possui o plugin WSL.

Esse plugin permite a interação do editor de texto Visual Studio Code com o WSL 2.

Código de exemplo

⚠️ É possível utilizar o Explorador de Arquivos do Microsoft Windows para gerenciar as pastas e arquivos que estão dentro do WSL 2.

Para testar a configuração, crie um arquivo e digite o seguinte código:

# -*- coding: utf-8 -*-
"""Python - PyGObject - GTK."""

import gi

gi.require_version(namespace='Gtk', version='4.0')
gi.require_version(namespace='Adw', version='1')

from gi.repository import Adw, Gio, Gtk

Adw.init()


class ExampleWindow(Gtk.ApplicationWindow):

    def __init__(self, **kwargs):
        super().__init__(**kwargs)

        self.set_title(title='Python - PyGObject - GTK')
        self.set_default_size(width=int(1366 / 2), height=int(768 / 2))
        self.set_size_request(width=int(1366 / 2), height=int(768 / 2))

        headerbar = Gtk.HeaderBar.new()
        self.set_titlebar(titlebar=headerbar)

        menu_button_model = Gio.Menu()
        menu_button_model.append('Preferências', 'app.preferences')

        menu_button = Gtk.MenuButton.new()
        menu_button.set_icon_name(icon_name='open-menu-symbolic')
        menu_button.set_menu_model(menu_model=menu_button_model)
        headerbar.pack_end(child=menu_button)

        # O seu código aqui:
        # ...


class ExampleApplication(Adw.Application):

    def __init__(self):
        super().__init__(application_id='br.com.justcode.Example',
                         flags=Gio.ApplicationFlags.FLAGS_NONE)

        self.create_action('quit', self.exit_app, ['<primary>q'])
        self.create_action('preferences', self.on_preferences_action)

    def do_activate(self):
        win = self.props.active_window
        if not win:
            win = ExampleWindow(application=self)
        win.present()

    def do_startup(self):
        Gtk.Application.do_startup(self)

    def do_shutdown(self):
        Gtk.Application.do_shutdown(self)

    def on_preferences_action(self, action, param):
        print('Ação app.preferences foi ativa.')

    def exit_app(self, action, param):
        self.quit()

    def create_action(self, name, callback, shortcuts=None):
        action = Gio.SimpleAction.new(name, None)
        action.connect('activate', callback)
        self.add_action(action)
        if shortcuts:
            self.set_accels_for_action(f'app.{name}', shortcuts)


if __name__ == '__main__':
    import sys

    app = ExampleApplication()
    app.run(sys.argv)

⚠️ É importante notar que o código não está rodando de forma nativa no Microsoft Windows, mas sim, sendo executado no Linux e exibido no Windows.

Como criar um aplicativo com Python e o toolkit GTK no macOS

Este guia descreve como preparar seu ambiente de desenvolvimento no macOS para criar aplicações utilizando a linguagem de programação Python (PyGObject) e o toolkit gráfico GTK.

Preparar o ambiente de desenvolvimento no macOS é um processo direto. Na maioria dos casos, todos os pacotes necessários estão disponíveis através do Homebrew.

Instalação

Os comandos a seguir permitirão a execução do binding PyGObject tanto na instalação local do Python quanto em um ambiente virtual (recomendado).

brew install \
python@3.12 \
pygobject3 \
adwaita-icon-theme \
libadwaita \
gtk4

Ambientes Virtuais

Se você ainda não os utiliza, este é um bom momento para explorar algumas opções:

Criando um Ambiente Virtual

Acesse a pasta raiz do seu projeto, abra um terminal e execute o seguinte comando:

python3 -m venv venv

Para criar um ambiente virtual utilizando uma versão específica da linguagem Python, você pode usar o comando:

python3.X -m venv venv

⚠️ Substitua X pela versão do Python que você deseja utilizar. ⚠️ A versão desejada deve estar instalada no seu sistema operacional!

Ativando o Ambiente Virtual

Após a criação, o ambiente virtual precisa ser ativado. Caso contrário, os pacotes serão instalados na sua instalação global do Python, e não no ambiente virtual.

Para ativar o ambiente virtual:

source venv/bin/activate

Instalando o Binding

Com o ambiente virtual ativo, comece atualizando o gerenciador de pacotes do Python (pip) com o comando:

python -m pip install \
--upgrade pip

Em seguida, instale o binding PyGObject e a biblioteca PyGObject-stubs com o comando:

pip install \
pygobject \
PyGObject-stubs

Com isso, você pode iniciar o desenvolvimento em um ambiente com dependências isoladas.

Testando

A maneira mais simples de testar a comunicação entre a linguagem de programação Python e o toolkit gráfico GTK é executar o seguinte comando no terminal:

python3 -c "import gi"

⚠️ Lembre-se que o comando deve ser executado com o ambiente virtual ativo!

Se nenhum erro for retornado após a execução do comando, a instalação e configuração estão corretas.

Código de Exemplo

Para testar a configuração no seu editor de texto ou IDE, utilize o seguinte código de exemplo:

# -*- coding: utf-8 -*-
"""Python - PyGObject - GTK."""

import gi

gi.require_version(namespace='Gtk', version='4.0')
gi.require_version(namespace='Adw', version='1')

from gi.repository import Adw, Gio, Gtk

Adw.init()


class ExampleWindow(Gtk.ApplicationWindow):

    def __init__(self, **kwargs):
        super().__init__(**kwargs)

        self.set_title(title='Python - PyGObject - GTK')
        self.set_default_size(width=int(1366 / 2), height=int(768 / 2))
        self.set_size_request(width=int(1366 / 2), height=int(768 / 2))

        headerbar = Gtk.HeaderBar.new()
        self.set_titlebar(titlebar=headerbar)

        menu_button_model = Gio.Menu()
        menu_button_model.append('Preferências', 'app.preferences')

        menu_button = Gtk.MenuButton.new()
        menu_button.set_icon_name(icon_name='open-menu-symbolic')
        menu_button.set_menu_model(menu_model=menu_button_model)
        headerbar.pack_end(child=menu_button)

        # O seu código aqui:
        # ...


class ExampleApplication(Adw.Application):

    def __init__(self):
        super().__init__(application_id='br.com.justcode.Example',
                         flags=Gio.ApplicationFlags.FLAGS_NONE)

        self.create_action('quit', self.exit_app, ['<primary>q'])
        self.create_action('preferences', self.on_preferences_action)

    def do_activate(self):
        win = self.props.active_window
        if not win:
            win = ExampleWindow(application=self)
        win.present()

    def do_startup(self):
        Gtk.Application.do_startup(self)

    def do_shutdown(self):
        Gtk.Application.do_shutdown(self)

    def on_preferences_action(self, action, param):
        print('Ação app.preferences foi ativa.')

    def exit_app(self, action, param):
        self.quit()

    def create_action(self, name, callback, shortcuts=None):
        action = Gio.SimpleAction.new(name, None)
        action.connect('activate', callback)
        self.add_action(action)
        if shortcuts:
            self.set_accels_for_action(f'app.{name}', shortcuts)


if __name__ == '__main__':
    import sys

    app = ExampleApplication()
    app.run(sys.argv)

Como criar um aplicativo com Python e o toolkit GTK no Linux

Para preparar o ambiente de desenvolvimento para a criação de aplicativos com a linguagem de programação Python (PyGObject) e o toolkit gráfico GTK no Linux.

Preparar o ambiente de desenvolvimento em distribuições Linux é bem simples. Na maioria dos casos, todos os pacotes necessários estão nos repositórios e podem ser instalados por meio do gerenciador de pacotes da distribuição.

É importante notar que, atualmente, a melhor forma de iniciar um novo projeto GTK é utilizando o IDE Gnome Builder juntamente com o sistema de empacotamento/distribuição Flatpak 💜.

Instalação

Os comandos a seguir permitirão a execução do binding PyGObject na instalação local do Python, bem como sua utilização em um ambiente virtual (recomendado).

Arch Linux

Site oficial da distribuição Linux Arch Linux.

Dependências
sudo pacman -S \
python \
python-pip \
cairo \
pkgconf \
gobject-introspection \
gtk4 \
libadwaita \
blueprint-compiler

Fedora

Site oficial da distribuição Linux Fedora.

Dependências
sudo dnf install \
python3 \
python3-devel \
python3-gobject \
gcc \
pkg-config \
cairo-devel \
cairo-gobject-devel \
gobject-introspection-devel \
gtk4 \
gtk4-devel \
gtk4-devel-tools \
libadwaita-devel \
blueprint-compiler

openSUSE Tumbleweed

Site oficial da distribuição Linux openSUSE Tumbleweed.

Dependências
sudo zypper install \
python311-devel \
python311-gobject \
python311-gobject-Gdk \
gcc \
pkgconf-pkg-config \
cairo-devel \
gobject-introspection-devel \
libgtk-4-1 \
gtk4-devel \
gtk4-tools \
libadwaita-devel

Ubuntu

Site oficial da distribuição Linux Ubuntu.

Dependências
sudo apt install \
python3-full \
python3-dev \
python3-gi \
python3-gi-cairo \
libcairo2-dev \
libgirepository1.0-dev \
gir1.2-gtk-4.0 \
libgtk-4-dev \
libadwaita-1-dev \
gtk-4-examples

Ao finalizar a instalação dos pacotes, a linguagem de programação Python, o binding PyGObject e as bibliotecas do GTK estarão instalados e prontos para uso 🚀.

Ambientes virtuais

Se você ainda não os utiliza, este é um bom momento para testar algumas opções:

Criando o ambiente virtual

Acesse a pasta raiz do seu projeto, abra um terminal e execute o comando:

python3 -m venv venv

Para criar o ambiente virtual utilizando uma versão específica da linguagem de programação Python, pode ser utilizado o comando:

python3.X -m venv venv

⚠️ Substitua o X pela versão da linguagem de programação Python que deseja utilizar.

⚠️ A versão desejada deve estar instalada no sistema operacional!

Ativando o ambiente virtual

Após ser criado, o ambiente virtual precisa ser ativado. Caso contrário, a instalação dos pacotes será realizada na instalação local da linguagem de programação Python e não no ambiente virtual.

Para ativar o ambiente virtual:

source venv/bin/activate

Instalando o binding

Com o ambiente virtual ativo, vamos começar atualizando o gerenciador de pacotes do Python (pip) com o comando:

python -m pip install \
--upgrade pip

Em seguida, instalaremos o binding PyGObject e a biblioteca PyGObject-stubs com o comando:

pip install \
pygobject \
PyGObject-stubs

Perfeito! Com isso, podemos iniciar o desenvolvimento em um ambiente onde as dependências estão isoladas 😃.

Testando

A forma mais simples de testar a comunicação entre a linguagem de programação Python e o toolkit gráfico GTK é executar no terminal o comando:

python3 -c "import gi"

⚠️ Lembre-se que o comando deve ser executado com o ambiente virtual ativo!

Se ao executar o comando nenhum erro for retornado, a instalação e a configuração estão corretas 👍👋👋.

Código de exemplo

Para testar a configuração no seu editor de texto ou IDE, utilize o seguinte código de exemplo:

# -*- coding: utf-8 -*-
"""Python - PyGObject - GTK."""

import gi

gi.require_version(namespace='Gtk', version='4.0')
gi.require_version(namespace='Adw', version='1')

from gi.repository import Adw, Gio, Gtk

Adw.init()


class ExampleWindow(Gtk.ApplicationWindow):

    def __init__(self, **kwargs):
        super().__init__(**kwargs)

        self.set_title(title='Python - PyGObject - GTK')
        self.set_default_size(width=int(1366 / 2), height=int(768 / 2))
        self.set_size_request(width=int(1366 / 2), height=int(768 / 2))

        headerbar = Gtk.HeaderBar.new()
        self.set_titlebar(titlebar=headerbar)

        menu_button_model = Gio.Menu()
        menu_button_model.append('Preferências', 'app.preferences')

        menu_button = Gtk.MenuButton.new()
        menu_button.set_icon_name(icon_name='open-menu-symbolic')
        menu_button.set_menu_model(menu_model=menu_button_model)
        headerbar.pack_end(child=menu_button)

        # O seu código aqui:
        # ...


class ExampleApplication(Adw.Application):

    def __init__(self):
        super().__init__(application_id='br.com.justcode.Example',
                         flags=Gio.ApplicationFlags.FLAGS_NONE)

        self.create_action('quit', self.exit_app, ['<primary>q'])
        self.create_action('preferences', self.on_preferences_action)

    def do_activate(self):
        win = self.props.active_window
        if not win:
            win = ExampleWindow(application=self)
        win.present()

    def do_startup(self):
        Gtk.Application.do_startup(self)

    def do_shutdown(self):
        Gtk.Application.do_shutdown(self)

    def on_preferences_action(self, action, param):
        print('Ação app.preferences foi ativa.')

    def exit_app(self, action, param):
        self.quit()

    def create_action(self, name, callback, shortcuts=None):
        action = Gio.SimpleAction.new(name, None)
        action.connect('activate', callback)
        self.add_action(action)
        if shortcuts:
            self.set_accels_for_action(f'app.{name}', shortcuts)


if __name__ == '__main__':
    import sys

    app = ExampleApplication()
    app.run(sys.argv)

Como criar um aplicativo com Python e GTK no MS Windows

Hoje veremos como preparar o ambiente de desenvolvimento para a criação de aplicativos com a linguagem de programação Python (PyGObject) e o toolkit gráfico GTK no Microsoft Windows.

MSYS2

O MSYS2 permite que pacotes, ferramentas e bibliotecas do Linux sejam instalados e executados de forma nativa no Microsoft Windows.

Para a instalação e gestão dos pacotes, o MSYS2 utiliza o gerenciador de pacotes Pacman.

Instalação

A instalação do MSYS2 é muito simples.

Antes de mais nada, acesse o site oficial https://www.msys2.org/ e realize o download do instalador.

Assim que o download for concluído, dê dois cliques sobre o instalador que foi baixado.

O instalador é muito simples e não é necessário alterar as configurações padrão que são exibidas nas telas.

Clique em Next e avance até finalizar a instalação.

Com o fim da instalação, procure pelo terminal do MSYS2 no menu Iniciar do Microsoft Windows.

Com o terminal aberto, realize a atualização dos pacotes que vêm instalados:

pacman -Syu
````

Assim que as atualizações estiverem finalizadas, **pode ser** necessário fechar e abrir o terminal novamente.

## GTK

O comando exibido **nesta seção** irá instalar as bibliotecas do GTK, a linguagem de programação [Python](https://www.python.org/) e o binding [PyGObject](https://pypi.org/project/PyGObject/).

### Dependências

> 🚨 Os comandos abaixo devem ser executados no **terminal do MSYS2**\!

```bash
pacman -S \
mingw-w64-x86_64-python3 \
mingw-w64-x86_64-python3-pip \
mingw-w64-x86_64-python3-gobject \
mingw-w64-x86_64-python-autopep8 \
mingw-w64-x86_64-python-pylint \
mingw-w64-x86_64-python-isort \
mingw-w64-x86_64-python-poetry \
mingw-w64-x86_64-blueprint-compiler \
mingw-w64-x86_64-gtk4 \
mingw-w64-x86_64-libadwaita \
mingw-w64-x86_64-gettext \
mingw-w64-x86_64-libxml2 \
mingw-w64-x86_64-librsvg \
mingw-w64-x86_64-pkgconf \
mingw-w64-x86_64-gcc

Após instalar as dependências, precisamos adicionar algumas pastas ao PATH do sistema operacional.

  1. Acesse as configurações (settings) -> pesquise (Search) pelo aplicativo "Configurações avançadas do sistema" (Advanced system settings) -> clique em "Variáveis de ambiente" (Environment variables).

  2. selecione (Path) -> e clique em "Editar" (Edit) -> Adicione os seguintes caminhos:

    plaintext C:\msys64\mingw64\include C:\msys64\mingw64\bin C:\msys64\mingw64\lib

Após configurar os diretórios acima nas variáveis de ambiente do Microsoft Windows, abra o terminal MinGW x64 e digite:

python3 -c "import gi"

⚠️ Não é o terminal do MSYS2, mas sim o terminal MinGW x64.

Para testar via PowerShell ou outros terminais:

C:\msys64\mingw64\bin\python3 -c "import gi"

Se ao executar o comando nenhum erro for retornado, a instalação e configuração estão corretas 👍👋👋.

Código de exemplo

Para testar a configuração, crie um arquivo e digite o seguinte código nele:

# -*- coding: utf-8 -*-
"""Python - PyGObject - GTK."""

import gi

gi.require_version(namespace='Gtk', version='4.0')
gi.require_version(namespace='Adw', version='1')

from gi.repository import Adw, Gio, Gtk

Adw.init()


class ExampleWindow(Gtk.ApplicationWindow):

    def __init__(self, **kwargs):
        super().__init__(**kwargs)

        self.set_title(title='Python - PyGObject - GTK')
        self.set_default_size(width=int(1366 / 2), height=int(768 / 2))
        self.set_size_request(width=int(1366 / 2), height=int(768 / 2))

        headerbar = Gtk.HeaderBar.new()
        self.set_titlebar(titlebar=headerbar)

        menu_button_model = Gio.Menu()
        menu_button_model.append('Preferências', 'app.preferences')

        menu_button = Gtk.MenuButton.new()
        menu_button.set_icon_name(icon_name='open-menu-symbolic')
        menu_button.set_menu_model(menu_model=menu_button_model)
        headerbar.pack_end(child=menu_button)

        # O seu código aqui:
        # ...


class ExampleApplication(Adw.Application):

    def __init__(self, **kwargs):
        super().__init__(application_id='br.com.justcode.Example',
                         flags=Gio.ApplicationFlags.FLAGS_NONE,
                         **kwargs) # Adicionado **kwargs para consistência

        self.create_action('quit', self.exit_app, ['<primary>q'])
        self.create_action('preferences', self.on_preferences_action)

    def do_activate(self):
        win = self.props.active_window
        if not win:
            win = ExampleWindow(application=self)
        win.present()

    def do_startup(self):
        Gtk.Application.do_startup(self)

    def do_shutdown(self):
        Gtk.Application.do_shutdown(self)

    def on_preferences_action(self, action, param):
        print('Ação app.preferences foi ativada.') # Corrigido para "ativada"

    def exit_app(self, action, param):
        self.quit()

    def create_action(self, name, callback, shortcuts=None):
        action = Gio.SimpleAction.new(name, None)
        action.connect('activate', callback)
        self.add_action(action)
        if shortcuts:
            self.set_accels_for_action(f'app.{name}', shortcuts)


if __name__ == '__main__':
    import sys

    app = ExampleApplication()
    app.run(sys.argv)

Aprenda a instalar a Godot engine no Linux em minutos

A Godot Engine é uma ferramenta poderosa e de código aberto para o desenvolvimento de jogos 2D e 3D.

Se você está procurando criar seus próprios jogos no Linux, este guia vai te mostrar como instalar a Godot em diferentes distribuições.

O Que é a Godot Engine?

A Godot é um motor de jogos altamente flexível, projetado para permitir o desenvolvimento de jogos de forma intuitiva e eficiente.

Com ela, você pode criar jogos tanto em 2D quanto em 3D, utilizando uma interface amigável e um sistema de script poderoso.

Sendo de código aberto, ela é gratuita e continuamente atualizada pela comunidade.

Instalando a Godot no Linux

A instalação da Godot no Linux pode variar dependendo da distribuição que você usa.

Abaixo, estão instruções para algumas das distribuições Linux mais populares, além de uma opção geral de instalação usando o site oficial da Godot.

1. Instalação no Arch Linux

Para usuários de Arch Linux, a instalação da Godot pode ser feita diretamente a partir do gerenciador de pacotes pacman.

Abra o terminal e execute o seguinte comando:

sudo pacman -S \
godot

2. Instalação no openSUSE Tumbleweed

Se você está usando o openSUSE Tumbleweed, pode instalar a Godot usando o gerenciador de pacotes zypper com o comando abaixo:

sudo zypper install \
godot

3. Instalação via Flathub

Caso a sua distribuição Linux tenha suporte a Flatpak, você pode utilizar o Flathub para realizar a instalação da Godot engine:

Também é possível realizar a instalação através do comando:

flatpak install flathub \
org.godotengine.Godot

4. Instalação via site oficial

Caso sua distribuição Linux não tenha um pacote oficial da Godot ou você prefira usar a versão mais recente disponível no site oficial, siga os passos abaixo:

  1. Acesse o site oficial da Godot.
  2. Baixe o binário da Godot.
  3. Renomeie o arquivo baixado para godot.
  4. Abrar um terminal e execute o comando echo $PATH para verificar os diretórios que aceitam arquivos binário.
  5. Os diretórios mais comuns são ~/bin e ~/.local/bin.
  6. Copie o binário para um desses diretórios.
4. Configurando o ícone da Godot

Para tornar a Godot acessível diretamente do seu menu de aplicativos com um ícone dedicado, siga estas etapas adicionais:

  1. Baixe o ícone da Godot aqui, renomeie-o para godot e mova-o para um dos seguintes diretórios:

  2. ~/.icons

  3. ~/.local/share/icons
5. Configurando o lançador da Godot
  1. Crie um arquivo de atalho no diretório ~/.local/share/applications com o nome godot.desktop. O conteúdo do arquivo deve ser o seguinte:
[Desktop Entry]
Categories=Development;
Comment=Godot engine.
Exec=godot
Icon=godot
Name=Godot
Path=~/.local/share/applications
StartupNotify=true
Terminal=false
Type=Application
Version=1.0

Isso permitirá que você inicie a Godot diretamente do menu de aplicativos do seu ambiente gráfico.

Conclusão

A instalação da Godot engine no Linux é simples e rápida, seja utilizando os repositórios oficiais da sua distribuição ou baixando diretamente do site da Godot.

Com este guia, você já pode começar a desenvolver seus jogos no Linux com facilidade.

Seja para projetos em 2D ou 3D, a Godot é uma escolha sólida e acessível.

Boa sorte no desenvolvimento dos seus jogos!

Extra

Visual Studio Code