<?xml version='1.0' encoding='utf-8' ?>
<iCalendar xmlns:pentabarf='http://pentabarf.org' xmlns:xCal='urn:ietf:params:xml:ns:xcal'>
    <vcalendar>
        <version>2.0</version>
        <prodid>-//Pentabarf//Schedule//EN</prodid>
        <x-wr-caldesc></x-wr-caldesc>
        <x-wr-calname></x-wr-calname>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3L7UPX@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3L7UPX</pentabarf:event-slug>
            <pentabarf:title>Orientação a Objetos com Python do Zero</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261014T133000</dtstart>
            <dtend>20261014T170000</dtend>
            <duration>033000</duration>
            <summary>Orientação a Objetos com Python do Zero</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial curto</category>
            <url>https://talks.python.org.br/pybr26/talk/3L7UPX/</url>
            <location>Sala 1 / Sala 130</location>
            
            <attendee>Marcos Rocha</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HBQUW8@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HBQUW8</pentabarf:event-slug>
            <pentabarf:title>Criando seu primeiro bot para o telegram utilizando python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20261014T133000</dtstart>
            <dtend>20261014T170000</dtend>
            <duration>033000</duration>
            <summary>Criando seu primeiro bot para o telegram utilizando python</summary>
            <description>Ao longo da atividade, será construído um bot funcional com comandos personalizados, tratamento de diferentes tipos de mensagens, validação de dados e consumo de serviços externos. Serão abordados conceitos como handlers, filtros, middlewares lógicos, controle de contexto do usuário e boas práticas de segurança, incluindo o uso de variáveis de ambiente para proteção de credenciais.

Ao final, os participantes terão uma base sólida para expandir o projeto para casos mais complexos, como automações, notificações, bots conversacionais e integrações com bancos de dados e outros serviços.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial curto</category>
            <url>https://talks.python.org.br/pybr26/talk/HBQUW8/</url>
            <location>Sala 2 / Sala 131</location>
            
            <attendee>Bernardo De Castro</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NBWAU3@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NBWAU3</pentabarf:event-slug>
            <pentabarf:title>Automações Escaláveis com Python, Playwright e Docker</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261014T133000</dtstart>
            <dtend>20261014T170000</dtend>
            <duration>033000</duration>
            <summary>Automações Escaláveis com Python, Playwright e Docker</summary>
            <description>Neste tutorial, construiremos uma automação web completa em Python a partir de um cenário prático, evoluindo passo a passo de uma execução síncrona para uma arquitetura mais escalável. Utilizando Playwright, desenvolveremos a automação de um fluxo web real, explorando conceitos como navegação, preenchimento de formulários, Browser, BrowserContext e Page.

A partir dessa implementação inicial, introduziremos asyncio para entender, na prática, conceitos como coroutines, await, event loop, concorrência e asyncio.gather. Em seguida, distribuiremos o processamento entre múltiplos workers com contextos isolados, analisando como essa abordagem pode reduzir o tempo de execução em cenários com grande volume de tarefas.

Também discutiremos aspectos importantes da engenharia de automação, como organização do projeto, modularização, isolamento de execução, governança, sustentação e os desafios de utilizar Python como plataforma para RPA em ambientes corporativos. Ao final, a aplicação será preparada para execução em containers com Docker, aproximando o exemplo desenvolvido de uma arquitetura mais reproduzível e escalável.

O objetivo é mostrar não apenas como criar um robô que funciona, mas como evoluir uma automação simples para uma solução com fundamentos de engenharia de software, concorrência e escalabilidade, que possa servir como base para projetos reais.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial curto</category>
            <url>https://talks.python.org.br/pybr26/talk/NBWAU3/</url>
            <location>Sala 3 / Sala 211</location>
            
            <attendee>Mateus Santos Marques</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HZBMJZ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HZBMJZ</pentabarf:event-slug>
            <pentabarf:title>Automatizando Tarefas com Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261014T133000</dtstart>
            <dtend>20261014T170000</dtend>
            <duration>033000</duration>
            <summary>Automatizando Tarefas com Python</summary>
            <description>## Introdução e Automação de Arquivos
1. Boas-vindas e Introdução (10 min)
* Apresentação rápida do que será abordado
* Pergunta interativa: &quot;Qual foi a última tarefa chata que você fez manualmente?&quot;

2. Automação de arquivos e diretórios (40 min)
* Manipulando arquivos com os e shutil
* Criando, movendo, renomeando e excluindo arquivos
* Desafio prático: &quot;Caça ao Tesouro&quot; | Participantes recebem um conjunto bagunçado de arquivos e precisam organizá-los automaticamente com Python.

3. Automação de PDFs e Planilhas (35 min)
* Extraindo e manipulando PDFs com PyPDF2
* Automatizando Excel com openpyxl e pandas
* Desafio prático: &quot;Detetive dos Relatórios&quot; | Um PDF contém informações escondidas e os participantes precisam extrair os dados certos.

## Automação da Web e APIs
4. Automatizando Navegação na Web (40 min)
* Scraping básico com requests e BeautifulSoup
* Automação de Navegador com Selenium
* Desafio prático: &quot;RoboZilla&quot; | Criar um script para coletar preços de produtos e decidir qual comprar.

## Automação de Tarefas no Computador
5. Automação de Tarefas Locais (35 min)
* Simulando teclas e cliques com pyautogui
* Copiar e colar automaticamente com pyperclip
* Desafio prático: &quot;O Hacker da Planilha&quot; | Criar um bot que preenche formulários automaticamente.

6. Criando um Agendador de Tarefas (35 min)
* Automação recorrente com schedule
* Desafio final: &quot;O Mestre da Rotina&quot; | Criar um script que automatiza tarefas do dia a dia.

7. Encerramento e Compartilhamento (15 min)</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial curto</category>
            <url>https://talks.python.org.br/pybr26/talk/HZBMJZ/</url>
            <location>Sala 4 / Sala 208</location>
            
            <attendee>Mateus Santos</attendee>
            
            <attendee>Dâmaris Campos</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3FMRL3@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3FMRL3</pentabarf:event-slug>
            <pentabarf:title>Rumo ao Desconhecido: Tratando Drift em Machine Learning</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261015T090000</dtstart>
            <dtend>20261015T123000</dtend>
            <duration>033000</duration>
            <summary>Rumo ao Desconhecido: Tratando Drift em Machine Learning</summary>
            <description>Modelos de machine learning em produção sofrem &quot;drift&quot; (data ou concept drift), degradando o desempenho devido a mudanças nos dados reais e resultando em previsões desatualizadas. Esta palestra aborda estratégias práticas de detecção, métodos estatísticos, monitoramento de KPIs e técnicas de mitigação, como retreinamento inteligente e aprendizado adaptativo para sistemas de ML mais resilientes.
O que você vai aprender:
- Compreender os tipos de drift e seu impacto em modelos online.
- Implementar estratégias de monitoramento para data e concept drift.
- Explorar técnicas de mitigação para manter o desempenho do modelo.
- Integrar o tratamento de drift em fluxos de MLOps.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial curto</category>
            <url>https://talks.python.org.br/pybr26/talk/3FMRL3/</url>
            <location>Sala 1 / Sala 130</location>
            
            <attendee>Ariana Rodrigues Cursino</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VSVZ3S@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VSVZ3S</pentabarf:event-slug>
            <pentabarf:title>Negado pelo banco: crédito inclusivo com dados do BCB</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261015T140000</dtstart>
            <dtend>20261015T173000</dtend>
            <duration>033000</duration>
            <summary>Negado pelo banco: crédito inclusivo com dados do BCB</summary>
            <description>Conceder crédito para públicos que costumam ser recusados por grandes bancos exige mais do que evitar risco: exige compreender onde existe potencial de consumo com possibilidade real de inclusão sustentável. Este tutorial parte de um problema concreto do setor de cartões de crédito: como identificar regiões promissoras sem cair na armadilha de buscar apenas os mercados “perfeitos”, ignorando justamente a população que mais precisa de acesso financeiro.

Usando dados públicos do Banco Central do Brasil e Python, vamos construir uma análise exploratória capaz de apoiar a criação de um Score de Oportunidade, combinando indicadores como volume de crédito, crescimento da carteira, inadimplência e endividamento das famílias. A proposta é mostrar, na prática, como transformar séries econômicas públicas em inteligência territorial para decisões de negócio mais responsáveis.

Ao longo da atividade, participantes aprenderão a acessar bases públicas do BCB, coletar dados por API, tratar séries temporais com pandas, integrar indicadores em uma análise coerente e visualizar resultados em gráficos e rankings interpretáveis. O foco não será apenas técnico: também discutiremos a formulação do problema, a leitura crítica dos dados e os cuidados metodológicos ao trabalhar com crédito, inclusão financeira e risco.

O tutorial foi pensado para quem quer sair do exemplo artificial e trabalhar com dados reais, conectando Python, análise exploratória e contexto social.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial curto</category>
            <url>https://talks.python.org.br/pybr26/talk/VSVZ3S/</url>
            <location>Sala 1 / Sala 130</location>
            
            <attendee>Fernando Masanori Ashikaga</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SDPLU3@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SDPLU3</pentabarf:event-slug>
            <pentabarf:title>Packaging Python extensions with ABI3</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20261015T090000</dtstart>
            <dtend>20261015T123000</dtend>
            <duration>033000</duration>
            <summary>Packaging Python extensions with ABI3</summary>
            <description>In this tutorial we will cover how to move a Python extension package build setup to ABI3. The goal is to help maintainer reduce the build matrix by building it for only 1 Python version that is forwards compatible.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial curto</category>
            <url>https://talks.python.org.br/pybr26/talk/SDPLU3/</url>
            <location>Sala 2 / Sala 131</location>
            
            <attendee>Filipe Fernandes</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>CQXNFW@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CQXNFW</pentabarf:event-slug>
            <pentabarf:title>Dojo de MicroPython: controle um carrinho colaborativamente</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261015T140000</dtstart>
            <dtend>20261015T173000</dtend>
            <duration>033000</duration>
            <summary>Dojo de MicroPython: controle um carrinho colaborativamente</summary>
            <description>Iremos utilizar a BBC micro:bit para aprender os conceitos do MicroPython. Após os participantes estarem nivelados, vamos controlar o carrinho Cutebot de forma colaborativa através de um coding dojo, onde todos irão contribuir na construção do algoritmo do carrinho.

Em um coding dojo, temos sempre duas pessoas à frente do computador: o piloto ativamente digitando e o co-piloto para auxiliá-lo. Após 5min, o round se encerra, sendo o co-piloto promovido à piloto e um novo participante se torna o co-piloto do próximo round.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial curto</category>
            <url>https://talks.python.org.br/pybr26/talk/CQXNFW/</url>
            <location>Sala 2 / Sala 131</location>
            
            <attendee>Juliana Karoline de Sousa</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>FHCJ3Q@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-FHCJ3Q</pentabarf:event-slug>
            <pentabarf:title>Criando aplicações de linha de comando amáveis</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261015T140000</dtstart>
            <dtend>20261015T173000</dtend>
            <duration>033000</duration>
            <summary>Criando aplicações de linha de comando amáveis</summary>
            <description>Comandos acessados pelo terminal são ferramentas poderosas: permitem automação, funcionam local ou remotamente e são parte central do ecossistema UNIX, o sistema operacional mais influente das últimas décadas. Mas muitas aplicações de linha de comando feitas com Python ignoram padrões fundamentais dessa filosofia, tornando-as difíceis de usar, inconsistentes ou verborrágicas.
Este tutorial nasce da frustração com ferramentas mal projetadas, que não consideraram a experiência do usuário quando foram desenvolvidas. Vamos aprender como criar CLIs agradáveis, que seguem convenções esperadas e funcionam bem tanto para humanos quanto para scripts e LLMs.
Usaremos apenas a biblioteca padrão (`argparse`) para garantir simplicidade e portabilidade. Também veremos boas práticas de _design_ de CLIs: separação de responsabilidades (entrada, lógica, saída), carregamento preguiçoso de módulos, preocupações com desempenho e como evitar armadilhas comuns.

A atividade incluirá:
- Exemplos reais de boas e más CLIs (inclusive de projetos populares);
- Breve histórico dos terminais e da filosofia UNIX;
- Diferenças entre CLI, TUI e GUI, e quando faz sentido cada uma;
- Casos de uso que ilustram a importância de uma boa interface de terminal;
- Exercícios práticos para criar CLIs úteis e respeitosas com quem as usa.

Você já perdeu minutos preciosos da sua vida tentando entender ou rodar um comando mal feito?</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial curto</category>
            <url>https://talks.python.org.br/pybr26/talk/FHCJ3Q/</url>
            <location>Sala 3 / Sala 211</location>
            
            <attendee>Álvaro Justen</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VLRKT9@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VLRKT9</pentabarf:event-slug>
            <pentabarf:title>Escape Room Pythonico com Lógica e Estruturas de Dados</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261015T140000</dtstart>
            <dtend>20261015T173000</dtend>
            <duration>033000</duration>
            <summary>Escape Room Pythonico com Lógica e Estruturas de Dados</summary>
            <description>Você está preso em um labirinto virtual e a única chave para a saída é o seu código! Neste workshop prático e gamificado voltado para iniciantes, vamos transformar o aprendizado de algoritmos e estruturas de dados em um desafio de sobrevivência.
Esqueça a teoria maçante: você aprenderá a aplicar lógica de programação, pilhas, filas e outras estruturas fundamentais de Python para resolver enigmas práticos e “escapar” de cada nível. Se você costuma travar diante da tela em branco ou acha que algoritmos são um bicho de sete cabeças, venha treinar seu cérebro, aprender a quebrar problemas complexos em passos simples e construir uma base sólida para a sua carreira de forma divertida. Ninguém fica para trás, mas todos terão que codar para sair!</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial curto</category>
            <url>https://talks.python.org.br/pybr26/talk/VLRKT9/</url>
            <location>Sala 4 / Sala 208</location>
            
            <attendee>Gustavo Caetano</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>TZXUVC@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-TZXUVC</pentabarf:event-slug>
            <pentabarf:title>Agentes Autônomos de IA com Hermes Agent</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T100000</dtstart>
            <dtend>20261016T104500</dtend>
            <duration>004500</duration>
            <summary>Agentes Autônomos de IA com Hermes Agent</summary>
            <description>Essa palestra vai mostrar como três movimentos estão convergindo para ampliar o que conseguimos construir com IA: as CLIs de programação, o ecossistema reutilizável de skills e servidores do Model Context Protocol (MCP) e os agentes autônomos com memória persistente.

A partir dessa evolução, vamos explorar o Hermes Agent, projeto open source da Nous Research cujo núcleo é desenvolvido em Python. A palestra acompanha o ciclo em que um agente recebe um objetivo, usa o computador como ambiente de execução, combina terminal, arquivos, navegador, APIs e MCPs, verifica o resultado e preserva o contexto para as próximas tarefas.

Essa arquitetura será conectada a cenários de negócio nos quais a IA precisa permanecer disponível, reagir a eventos e executar processos que atravessam vários sistemas. Relatórios, monitoramento de indicadores, triagem de solicitações, produção de conteúdo e atendimento ajudam a mostrar o papel da memória, dos agendamentos, dos webhooks e da supervisão humana. O conteúdo é voltado a pessoas desenvolvedoras que já usam IA em chats ou no terminal e querem conectá-la aos dados, aos sistemas e aos processos de uma organização.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/TZXUVC/</url>
            <location>Principal</location>
            
            <attendee>Felipe Azambuja</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>FELRD8@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-FELRD8</pentabarf:event-slug>
            <pentabarf:title>Camila Maia</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T111000</dtstart>
            <dtend>20261016T121000</dtend>
            <duration>010000</duration>
            <summary>Camila Maia</summary>
            <description>Engenheira de software, especialista em Developer Experience e apaixonada por código aberto, Camila também é cofundadora da [Cumbuca Dev ]([url](https://cumbuca.dev/)) comunidade que trabalha para tornar o open source mais acessível e inclusivo no Brasil.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://talks.python.org.br/pybr26/talk/FELRD8/</url>
            <location>Principal</location>
            
            <attendee>Camila Maia</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HWYTEH@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HWYTEH</pentabarf:event-slug>
            <pentabarf:title>O poder dos conjuntos</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T140000</dtstart>
            <dtend>20261016T144500</dtend>
            <duration>004500</duration>
            <summary>O poder dos conjuntos</summary>
            <description>Conjuntos são a base da lógica booleana e dos bancos de dados. Por esta razão, as classes `set` e `frozenset` do Python, com suas ricas APIs e operadores, podem simplificar seu código, torná-lo mais legível e eficiente ao mesmo tempo. Além das inúmeras aplicações práticas, conjuntos em Python:
* Exemplificam alguns dos recursos mais interessantes de Python: iteradores, sobrecarga de operadores, compreensões, e polimorfismo.
* As APIs de `set` e `frozenset` são uma aula de design de API pythonica.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/HWYTEH/</url>
            <location>Principal</location>
            
            <attendee>Luciano Ramalho</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XCLXZQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XCLXZQ</pentabarf:event-slug>
            <pentabarf:title>Micro-monolith with Pyramid: team boundaries, no chaos</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T145000</dtstart>
            <dtend>20261016T153500</dtend>
            <duration>004500</duration>
            <summary>Micro-monolith with Pyramid: team boundaries, no chaos</summary>
            <description>The most common way to divide systems follows the domain: payments here, users there, notifications somewhere else. What that question ignores is: who owns each piece?

The micro-monolith starts from a different premise: the right boundary is the team boundary, not the semantic one. If two different teams develop features in the same service, you have an organizational problem that no architecture will solve. If a team has clear ownership over a service — even if it spans concepts from different domains — you have real autonomy.

Pyramid is the Python framework that doesn&#x27;t make decisions for you. No mandatory ORM, no imposed folder structure, no magic. That makes it the natural choice for an architecture where you want to be explicit about boundaries — not the framework.

In this talk I share one way of thinking about organizing services around teams (not domains), explicit public contracts with Pyramid, and the practical decision of where a new feature belongs.

You&#x27;ll leave with a mental model that challenges the mainstream and a concrete Python structure to apply the next day.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/XCLXZQ/</url>
            <location>Principal</location>
            
            <attendee>Tomás Silveira Corrêa</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>CVVXH8@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CVVXH8</pentabarf:event-slug>
            <pentabarf:title>Async é isso</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20261016T155500</dtstart>
            <dtend>20261016T164000</dtend>
            <duration>004500</duration>
            <summary>Async é isso</summary>
            <description>Com o modo free-threaded (PEP 703), o Python finalmente abraçou o paralelismo real, permitindo que as aplicações utilizem múltiplos núcleos de CPU simultaneamente. Mas essa liberdade tem um preço: o antigo Global Interpreter Lock (GIL), muitas vezes visto como o vilão da performance, era também o &quot;anjo da guarda&quot; que protegia nossos códigos contra corrupção de memória e race conditions implícitas.

Nesta palestra, vou desconstruir o mito de que &quot;remover o GIL deixa tudo magicamente mais rápido e seguro&quot;. Através de demonstrações de código (talvez live coding), mostrarei como estruturas de dados tradicionais podem quebrar em ambiente multi-core e por que até mesmo aplicações modernas baseadas em asyncio podem cair em armadilhas quando interagem com thread pools. A ideia é sair desta apresentação com um mapa claro de como auditar seu código atual e arrumar se necessário para extrair o máximo de performance do novo ecossistema Python, sem sacrificar a estabilidade.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/CVVXH8/</url>
            <location>Principal</location>
            
            <attendee>Pablo Henrique Aguilar</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QZH3HS@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QZH3HS</pentabarf:event-slug>
            <pentabarf:title>Caio Gomes</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20261016T170000</dtstart>
            <dtend>20261016T180000</dtend>
            <duration>010000</duration>
            <summary>Caio Gomes</summary>
            <description>Físico e especialista em Machine Learning e inteligência artificial, Caio Gomes tem uma trajetória incrível liderando times e produtos de IA em empresas como Amazon, Booking.com e Nubank. Atualmente, é Chief Data &amp; Analytics Officer e Chief Artificial Intelligence Officer do grupo Magalu.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://talks.python.org.br/pybr26/talk/QZH3HS/</url>
            <location>Principal</location>
            
            <attendee>Caio Gomes</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QE7YVK@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QE7YVK</pentabarf:event-slug>
            <pentabarf:title>thetaflow: Integrando redes neurais a modelos estatísticos</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T100000</dtstart>
            <dtend>20261016T104500</dtend>
            <duration>004500</duration>
            <summary>thetaflow: Integrando redes neurais a modelos estatísticos</summary>
            <description>O pacote _thetaflow_ é parte da minha tese de doutorado, na qual tenho o objetivo de integrar modelos de sobrevivência (estudos de tempo de vida) a redes neurais. Percebi ao longo da tese que as ideias aplicadas eram muito mais gerais e podiam ser usadas para virtualmente qualquer distribuição estatística, o que me motivou a implementar um pacote flexível e voltado para um framework de modelagem geral. Este novo framework supera o estado da arte em regressão distribucional, se comparando a pacotes existentes em R, como o gamlss.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/QE7YVK/</url>
            <location>Esmeralda 2</location>
            
            <attendee>Natan H da Silva</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>DRX3UD@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-DRX3UD</pentabarf:event-slug>
            <pentabarf:title>Criando servidores MCP com FastMCP e Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20261016T140000</dtstart>
            <dtend>20261016T144500</dtend>
            <duration>004500</duration>
            <summary>Criando servidores MCP com FastMCP e Python</summary>
            <description>O Model Context Protocol (MCP) permite que LLMs acessem dados e ferramentas externas de forma padronizada. Na Nekt, implementamos um servidor MCP que dá acesso aos dados de 100+ clientes via ferramentas como list_tables, execute_sql, read_file e get_table_preview. Nesta palestra: (1) O que é MCP e por que importa: o protocolo que padroniza como LLMs interagem com o mundo externo — tools, resources e prompts. (2) O servidor MCP com FastMCP: como definimos tools com tipagem Pydantic e docstrings que o LLM entende, usando o pattern de registro por decorador. (3) Autenticação OAuth 2.1 com PKCE: o fluxo completo desde o login do usuário, passando por SSO SAML, até a emissão de bearer tokens com escopo por tabela. (4) Deploy multi-cloud: como provisionamos o servidor MCP na infraestrutura do cliente (AWS ECS ou GCP Cloud Run) a partir do backend Django. (5) Bearer tokens com escopo granular: como um token dá acesso apenas a tabelas específicas do data warehouse. (6) Lições de produção: os edge cases de segurança e performance que descobrimos servindo 100+ organizações.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/DRX3UD/</url>
            <location>Esmeralda 2</location>
            
            <attendee>Andrio Frizon</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QM9TTY@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QM9TTY</pentabarf:event-slug>
            <pentabarf:title>Python na indústria: transformando vibração em decisões</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T145000</dtstart>
            <dtend>20261016T153500</dtend>
            <duration>004500</duration>
            <summary>Python na indústria: transformando vibração em decisões</summary>
            <description>Máquinas falam. Não com palavras, mas com sinais. Vibrações carregam informações importantes sobre o que está acontecendo, muito antes de uma falha acontecer. O desafio é conseguir interpretar esse “ruído” e transformá-lo em algo útil.

Nesta palestra, será explorado como dados de vibração podem ser analisados e transformados em informações que apoiam decisões, utilizando Python como ferramenta central. A apresentação começa com conceitos acessíveis de análise de sinais e evolui para um ponto crucial: o que muda quando esses dados não param de chegar?

Ao sair de análises pontuais para cenários em tempo real, o problema deixa de ser apenas entender os dados e passa a envolver também como estruturar sistemas capazes de lidar com fluxo contínuo de informação. Nesse contexto, entram discussões sobre organização de pipelines e arquiteturas escaláveis.

A proposta é oferecer uma visão conectando o mundo físico ao software, mostrando como transformar sinais em decisões em ambientes reais, de forma acessível e prática.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/QM9TTY/</url>
            <location>Esmeralda 2</location>
            
            <attendee>Maria Vitoria Sikora</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SDKRCF@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SDKRCF</pentabarf:event-slug>
            <pentabarf:title>Movendo Icebergs Para Um Floco de Neve</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T155500</dtstart>
            <dtend>20261016T164000</dtend>
            <duration>004500</duration>
            <summary>Movendo Icebergs Para Um Floco de Neve</summary>
            <description>Se você já trabalhou com pipelines de dados em produção, sabe que um projeto que &quot;funciona&quot; nem sempre é um projeto que escala. Nesta palestra, vou abrir o capô de uma arquitetura monolítica real — construída sobre Apache Iceberg para consolidação de dados — e mostrar como ela evoluiu para uma solução moderna no Snowflake.
Vou conduzir você pela linha do tempo dessa migração: como era a arquitetura original, quais dores técnicas começaram a aparecer com o crescimento, por que o Snowflake surgiu como resposta e quais foram as decisões que moldaram o novo desenho. Mais do que um case de sucesso, esta é uma narrativa honesta — incluindo os momentos em que tivemos que repensar escolhas no meio do caminho.
Se você está construindo ou mantendo plataformas de dados, vai sair daqui com referências concretas de arquitetura, critérios reais para avaliar migrações e, principalmente, com a clareza de que toda grande mudança começa com uma boa pergunta: &quot;será que o que temos hoje ainda é o suficiente para o amanhã?&quot;</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/SDKRCF/</url>
            <location>Esmeralda 2</location>
            
            <attendee>Gabu Bellon</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>KQWZ7V@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-KQWZ7V</pentabarf:event-slug>
            <pentabarf:title>Django aos 20: velho demais ou maduro o suficiente?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20261016T100000</dtstart>
            <dtend>20261016T104500</dtend>
            <duration>004500</duration>
            <summary>Django aos 20: velho demais ou maduro o suficiente?</summary>
            <description>Enquanto novos frameworks surgem prometendo revolucionar o desenvolvimento web, o Django segue firme há 20 anos resolvendo problemas reais em produção. Mas será que ele ainda faz sentido em 2026?  Nesta palestra, vamos além da comparação superficial com frameworks da moda e mostramos por que o Django continua sendo uma escolha poderosa para projetos web.

Vamos explorar o que você ganha &quot;de graça&quot; ao escolher Django: um ORM maduro que abstrai a complexidade do banco de dados, sistema de migrações automáticas, autenticação e autorização prontas para uso, admin integrado, proteção contra vulnerabilidades comuns e um ecossistema de bibliotecas construído ao longo de duas décadas por uma comunidade ativa.

Também vamos falar sobre como o Django está evoluindo. Com ferramentas como HTMX, é possível construir interfaces interativas e modernas sem a complexidade de um SPA em React ou Vue devolvendo o protagonismo ao servidor.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/KQWZ7V/</url>
            <location>Esmeralda 1</location>
            
            <attendee>Renne Rocha</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3EEQEY@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3EEQEY</pentabarf:event-slug>
            <pentabarf:title>Olá Zora! (ou como enfrento o caos, e o TDAH, diariamente)</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T140000</dtstart>
            <dtend>20261016T144500</dtend>
            <duration>004500</duration>
            <summary>Olá Zora! (ou como enfrento o caos, e o TDAH, diariamente)</summary>
            <description>Tenho mais chapéus do que é saudável a uma pessoa só: executivo de uma consultoria pequena, dev sênior em uma empresa internacional, voluntário e líder de uma comunidade open source, filho, pai, marido e com diversos boletos para pagar. 
Cada papel tem seu vocabulário, prazos, urgências e seu próprio modo de me consumir. Some a isso TDAH, os diversos interesses e hobbies, e o resultado é caótico.

Nessa apresentação eu conto como cheguei num workflow que parece funcionar pra mim:

- Notas em markdown como ponto de partida — uma forma de externalizar memória de trabalho e ancorar contexto entre janelas de atenção que duram pouco.
- Um agente de IA pra programação como catalisador: processos informais que eu carregava na cabeça viraram Skills e subagentes reutilizáveis.
- Zora, um assistente pessoal construído em cima disso, que cuida das tarefas chatas e repetitivas — documentar código, contabilizar horas, gerar relatórios, organizar burocracia — me deixando livre pra explorar as muitas ideias novas que aparecem no caminho.

Não é tutorial nem manifesto. É um relato pessoal, honesto, com o que custou caro descobrir, o que ainda não funciona, e por que essa é a MINHA solução — provavelmente não a sua, mas talvez possa ser a semente da sua automação</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/3EEQEY/</url>
            <location>Esmeralda 1</location>
            
            <attendee>Érico Andrei</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QYCQKB@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QYCQKB</pentabarf:event-slug>
            <pentabarf:title>Transições de Carreira: Da Educação ao Mercado de Dados</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T145000</dtstart>
            <dtend>20261016T153500</dtend>
            <duration>004500</duration>
            <summary>Transições de Carreira: Da Educação ao Mercado de Dados</summary>
            <description>Pessoas &gt; Tecnologia. Sigo este lema da comunidade e, por isso, me motivei a fazer esta palestra. Nela, apresentarei relatos e experiências pessoais sobre duas transições de carreira, começando como docente até a área de Ciência de Dados.

A apresentação começa com um breve background pessoal, apresentando minha trajetória e as motivações para as mudanças profissionais e os principais obstáculos encontrados durante esse processo.

Também abordarei o cenário atual do mercado de tecnologia para a área de dados, habilidades mais requisitadas, oportunidades, dificuldades enfrentadas por iniciantes e a importância do aprendizado contínuo em um setor em constante mudança.

Por fim, irei destacar nesta palestra o papel das comunidades python no desenvolvimento profissional, as trocas de conhecimento, organização de eventos e geração de oportunidades, mostrando como a participação ativa na comunidade contribui com isso.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/QYCQKB/</url>
            <location>Esmeralda 1</location>
            
            <attendee>Miky</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JS9GCS@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JS9GCS</pentabarf:event-slug>
            <pentabarf:title>IA no Caos: Pipelines Multimodais em Desastres Urbanos</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T155500</dtstart>
            <dtend>20261016T164000</dtend>
            <duration>004500</duration>
            <summary>IA no Caos: Pipelines Multimodais em Desastres Urbanos</summary>
            <description>Em cenários de desastres, a velocidade de resposta salva vidas. Para apoiar equipes de emergência, o desafio da engenharia vai além de rodar modelos isolados: é preciso criar uma solução capaz de processar imagens caóticas e transformá-las em informações úteis em tempo real.

Esta palestra apresenta os desafios técnicos e práticos por trás de modelos de visão computacional voltados para desastres urbanos. Discutiremos como estruturar uma pipeline de IA de ponta a ponta, focando na detecção de objetos em ambientes degradados por enchentes e desabamentos. Abordaremos como superar as falhas de modelos genéricos através da criação de um dataset específico, mostrando como foi feita a curadoria manual no Roboflow, a hospedagem no Kaggle e o uso do modelo multimodal Gemini-Flash para gerar imagens e enriquecer o conjunto de dados para classes críticas como civis, socorristas e animais.

Veremos como realizar o treinamento desse modelo utilizando a biblioteca Ultralytics (YOLO) no ecossistema Python. Por fim, utilizaremos uma interface no Gradio, hospedada no Hugging Face, para apresentar os resultados práticos da solução de forma totalmente visual e acessível, demonstrando o potencial da IA aplicada ao impacto social.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/JS9GCS/</url>
            <location>Esmeralda 1</location>
            
            <attendee>Carolina Soares</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JMEAQJ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JMEAQJ</pentabarf:event-slug>
            <pentabarf:title>Python p/ Blue Team: Monitoramento e Detecção em Tempo Real</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T100000</dtstart>
            <dtend>20261016T104500</dtend>
            <duration>004500</duration>
            <summary>Python p/ Blue Team: Monitoramento e Detecção em Tempo Real</summary>
            <description>Calouros de Engenharia apresentam uma ferramenta real de monitoramento para Blue Team desenvolvida utilizando apenas Python nativo. Mostraremos que não é preciso dominar frameworks complexos para criar soluções de segurança eficientes logo no início da graduação.

No projeto, você verá como foi construída uma solução prática que cobre:

• Leitura eficiente de arquivos de log massivos;
• Detecção de padrões de ameaças com expressões regulares (Regex);
• Notificação automatizada e instantânea via webhook.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/JMEAQJ/</url>
            <location>Topázio 2</location>
            
            <attendee>Kauany Comin</attendee>
            
            <attendee>Wiliam Junior da Maia</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>CLP9GF@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CLP9GF</pentabarf:event-slug>
            <pentabarf:title>Alerta de Desvio: Identificando Data Drift em Produção</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T140000</dtstart>
            <dtend>20261016T144500</dtend>
            <duration>004500</duration>
            <summary>Alerta de Desvio: Identificando Data Drift em Produção</summary>
            <description>Esta palestra abordará os desafios técnicos de manter modelos de machine learning confiáveis após o deploy, focando especificamente no fenômeno do Data Drift (deslocamento de covariáveis nas distribuições de entrada). Diferente do Concept Drift, onde as regras de negócio mudam, o Data Drift ocorre quando o perfil do público ou a natureza dos dados coletados se transforma, fazendo com que o modelo precise operar em cenários para os quais nunca foi treinado. O principal objetivo é instrumentalizar a comunidade a criar sistemas de monitoramento proativos e automatizados usando Python.
Apresentaremos como implementar testes estatísticos não paramétricos — como Kolmogorov-Smirnov (KS) para variáveis numéricas e Qui-Quadrado para variáveis categóricas — para comparar dados históricos de treino com os dados reais de produção em tempo real. Discutiremos a arquitetura para integrar essas validações de forma assíncrona nas esteiras de MLOps, utilizando ferramentas de código aberto como Evidently ou Alibi-detect. Ao final, o público entenderá como configurar gatilhos de alerta baseados em relatórios estatísticos visuais, permitindo que as equipes de dados intervenham (retreinando ou pausando o modelo) antes que a degradação silenciosa dos dados de entrada cause prejuízos financeiros ou decisões de negócios desatualizadas.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/CLP9GF/</url>
            <location>Topázio 2</location>
            
            <attendee>Ariana Rodrigues Cursino</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BRXSGM@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BRXSGM</pentabarf:event-slug>
            <pentabarf:title>dlt (data load tool): ingestão de dados do jeito Pythônico</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T145000</dtstart>
            <dtend>20261016T153500</dtend>
            <duration>004500</duration>
            <summary>dlt (data load tool): ingestão de dados do jeito Pythônico</summary>
            <description>Cada fonte de dados exige uma lógica própria de extração. Essa heterogeneidade é genuína e inevitável, e é exatamente ela que torna os scripts de extração um quadro em branco: sem uma estrutura compartilhada, pessoas diferentes trabalhando em fontes diferentes produzem soluções que crescem como dialetos paralelos dentro do mesmo time, repetindo estratégias de jeitos incompatíveis.

A saída óbvia seria adotar uma ferramenta ou plataforma baseada em conectores, mas essa troca tem dois custos que costumam aparecer cedo. O primeiro é estrutural: a ferramenta vive como um componente separado na arquitetura, com seu próprio ciclo de vida e overhead operacional. O segundo aparece quando as fontes são diversas ou pouco convencionais: as restrições para criar conectores customizados se tornam uma limitação de design, exatamente no ponto em que mais se precisaria de flexibilidade.

**dlt** oferece um terceiro caminho. Com conceitos como `resources`, `sources` e `pipelines` implementados em Python, a biblioteca traz comportamento e consistência de framework diretamente para a codebase, sem abrir mão da flexibilidade da linguagem. Nesta palestra vamos explorar esses componentes na prática e entender por que **dlt** vem se tornando uma escolha consolidada em plataformas de dados modernas.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/BRXSGM/</url>
            <location>Topázio 2</location>
            
            <attendee>Alan Molina</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VULZMM@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VULZMM</pentabarf:event-slug>
            <pentabarf:title>Caçando bugs em Python: do olho humano à IA</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261016T155500</dtstart>
            <dtend>20261016T164000</dtend>
            <duration>004500</duration>
            <summary>Caçando bugs em Python: do olho humano à IA</summary>
            <description>Como descobrir bugs no seu código e em projetos open source baseados em Python? Esta palestra mostrará técnicas e ferramentas utilizadas (e algumas criadas) pelo autor para encontrar bugs, começando há cerca de 20 anos.

Veremos técnicas englobando desde revisão manual, passando por ferramentas de fuzzing, até o uso estruturado de IA para encontrar problemas no código de pacotes, extensões e das próprias implementações do Python.

Os resultados dessas análises serão descritos e contextualizados, demonstrando sua abrangência e significância para os projetos avaliados.

Apesar do viés focado nas experiências do autor, também será apresentado um panorama das ferramentas e esforços existentes para a identificação de falhas em projetos em Python.

Por fim, fica o convite para que você apresente seu projeto ou código para ser analisado. Será que descobriremos mais bugs interessantes?</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/VULZMM/</url>
            <location>Topázio 2</location>
            
            <attendee>Daniel Diniz</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>FWPNAU@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-FWPNAU</pentabarf:event-slug>
            <pentabarf:title>Experiments in Agentic Coding</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T100000</dtstart>
            <dtend>20261017T104500</dtend>
            <duration>004500</duration>
            <summary>Experiments in Agentic Coding</summary>
            <description>To use coding agents well, you need an intuition for how they work and what they actually do. Without it, developers fall back on using agents like a more powerful chat window, and then struggle to understand why they get slop and unpredictable results.

The good news: building this intuition is easy. It takes only a little curiosity and a willingness to experiment.

This talk builds that intuition through simple experiments with persona prompts, starting with silly experiments like, &quot;pretend you are a Bjarne Stroustrup&quot; or &quot;pretend you are a goose&quot;, and progressing to &quot;pretend you are a Django novice,&quot; &quot;pretend you are an expert software architect.&quot;

We will solve FizzBuzz in Claude. Suprisingly this simple problem is sufficient to demonstrate some tips and traps when using agents. Along the way, we will demonstrate:

* model non-determinism
* how context windows work
* why context management matters, and how to track it
* session rewinding and forking
* zero-shot vs. multi-shot prompts
* plan mode vs. edit mode
* sub-agents and skills, including parallel exploration

The final demo shows how a default Claude session, without proper setup, produces bad tests and technical debt in Python. We then show how to use skills and sub-agents to produce good tests instead.

Developers will leave knowing how Claude actually works, how to prompt it for good results, and with a sub-agent/skills file they can use to improve their own tests.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/FWPNAU/</url>
            <location>Principal</location>
            
            <attendee>Edwin Jung</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JQE8YP@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JQE8YP</pentabarf:event-slug>
            <pentabarf:title>Hazel Saenz</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T111000</dtstart>
            <dtend>20261017T121000</dtend>
            <duration>010000</duration>
            <summary>Hazel Saenz</summary>
            <description>Developer Advocate da Amazon Web Services (AWS) para a América Latina e ex-AWS Serverless Hero, Hazel tem mais de 20 anos de experiência em desenvolvimento de aplicações e 6 anos de atuação com tecnologias de nuvem. É especialista em arquiteturas serverless, sistemas orientados a eventos e IA generativa na AWS, além de compartilhar conhecimento e experiências com comunidades de desenvolvedores em toda a América Latina.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://talks.python.org.br/pybr26/talk/JQE8YP/</url>
            <location>Principal</location>
            
            <attendee>Hazel Saenz</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>AA89SG@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-AA89SG</pentabarf:event-slug>
            <pentabarf:title>Quantum Leap: Building Real Quantum Programs with Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T140000</dtstart>
            <dtend>20261017T144500</dtend>
            <duration>004500</duration>
            <summary>Quantum Leap: Building Real Quantum Programs with Python</summary>
            <description>Quantum computing is no longer science fiction - it&#x27;s here, and Python is the gateway! In this talk, you&#x27;ll learn how to write quantum circuits and simulate or run them on actual quantum hardware using Python-based frameworks.

We’ll start by introducing the core principles of quantum computing, such as qubits, superposition, entanglement, and measurement, with simple visualizations. Then, we&#x27;ll dive into the practical side: writing Python code that defines quantum circuits, performs quantum logic operations, and interprets results. You&#x27;ll even see how to submit jobs to real quantum processors in the cloud.

Whether you&#x27;re a developer curious about quantum or a data scientist exploring next-gen computing, this talk gives you practical skills and mental models to understand and use quantum tools - today.

Key Takeaways:
- Understand basic quantum computing concepts in Python terms
- Build quantum circuits with Qiskit
- Simulate quantum behavior on classical hardware
- Access cloud-based quantum processors (e.g., IBM Quantum)
- Learn about real-world applications like quantum</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/AA89SG/</url>
            <location>Principal</location>
            
            <attendee>Beilak Aliev</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JGTEZV@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JGTEZV</pentabarf:event-slug>
            <pentabarf:title>Arte com matrizes: NumPy na programação criativa</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T145000</dtstart>
            <dtend>20261017T153500</dtend>
            <duration>004500</duration>
            <summary>Arte com matrizes: NumPy na programação criativa</summary>
            <description>Mesmo sem conhecimentos aprofundados de computação científica ou ciência de dados, todos nós podemos usar bibliotecas avançadas do Python para fazer muitas coisas diferentes!
Nesta palestra vamos apresentar alguns conceitos básicos do NumPy e da interfaces dos arrays multidimensionais, mostrando exemplos de aplicação em Python para fins criativos e expressivos, produzindo desenhos e animações.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/JGTEZV/</url>
            <location>Principal</location>
            
            <attendee>Alexandre B A Villares</attendee>
            
            <attendee>Jim Schmitz</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SPNGHP@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SPNGHP</pentabarf:event-slug>
            <pentabarf:title>O GIL perdeu o controle? Threads em Python na nova era</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T155500</dtstart>
            <dtend>20261017T164000</dtend>
            <duration>004500</duration>
            <summary>O GIL perdeu o controle? Threads em Python na nova era</summary>
            <description>Python é amplamente utilizado, mas quando o assunto é concorrência com threads, muitos desenvolvedores se frustram ao não obter o ganho de performance esperado. O principal responsável por esse comportamento é o GIL (Global Interpreter Lock), um mecanismo interno que controla a execução das threads.

Nesta palestra, vamos desmistificar o GIL de forma clara e acessível, entendendo por que ele existe, como impacta aplicações reais e em quais cenários ele se torna um problema. Além disso, exploraremos as mudanças mais recentes do Python que permitem maior controle sobre esse comportamento e abrem novas possibilidades para execução paralela.

Ao final, você terá uma visão prática para decidir quando usar threads, multiprocessing ou outras abordagens, evitando armadilhas comuns e escrevendo códigos mais eficientes.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/SPNGHP/</url>
            <location>Principal</location>
            
            <attendee>Ana Laura Berger dos Reis</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>CHGC83@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CHGC83</pentabarf:event-slug>
            <pentabarf:title>Karo Ladino-Puerto</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20261017T170500</dtstart>
            <dtend>20261017T180500</dtend>
            <duration>010000</duration>
            <summary>Karo Ladino-Puerto</summary>
            <description>Engenheira em Robótica, eterna estudante, líder de comunidade, PSF Fellow e cofundadora da Fundação Átoma. Karobot está à frente da PyLadies Colômbia desde 2018. Hoje faz parte do time que lidera a Python Colômbia e segue criando redes para sustentar e crescer na e com a tecnologia.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://talks.python.org.br/pybr26/talk/CHGC83/</url>
            <location>Principal</location>
            
            <attendee>Karo Ladino-Puerto</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SCKBBS@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SCKBBS</pentabarf:event-slug>
            <pentabarf:title>CRDTs - Tipo de dados replicados sem conflitos</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T100000</dtstart>
            <dtend>20261017T104500</dtend>
            <duration>004500</duration>
            <summary>CRDTs - Tipo de dados replicados sem conflitos</summary>
            <description>CRDTS (Conflict-free Replicated Data Types; ou Tipos de Dados e Replicados sem
Conflitos em portugues) são estruturas de dados criadas para computações distribuídas.
O que acontece se dois processos têm um valor e tentam modificar em paralelo depois? Uma condição de corrida!
Mas não com CRDTs! Essas estruturas garantem que a fusão dos dois valores, depois da modificação em paralelo, convirjam de forma determinística.
Nesta palestra vamos passar pelos conceitos básicos de um CRDTs e alguns exemplos de utilização no mundo real.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/SCKBBS/</url>
            <location>Esmeralda 2</location>
            
            <attendee>Edson Bomfim</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3XJEUH@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3XJEUH</pentabarf:event-slug>
            <pentabarf:title>Shazam da natureza: identificando animais por sons</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T140000</dtstart>
            <dtend>20261017T144500</dtend>
            <duration>004500</duration>
            <summary>Shazam da natureza: identificando animais por sons</summary>
            <description>Ecologistas utilizam sensores para monitorar ecossistemas e realizar estudo de comportamento. Eles utilizam sensores, que gravam sons ambientes, e utilizam espectrogramas para analizar esses dados.
Serão apresentado aqui como esses dados são analizados, bibliotecas existentes que ajudam, tipos de modelos usados para classificação dos sons (com foco em CNNs) e modelos fundacionais que são o estado da arte dessa área.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/3XJEUH/</url>
            <location>Esmeralda 2</location>
            
            <attendee>Ítalo Epifânio</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WGZH7S@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WGZH7S</pentabarf:event-slug>
            <pentabarf:title>Construindo uma plataforma de agentes com python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T145000</dtstart>
            <dtend>20261017T153500</dtend>
            <duration>004500</duration>
            <summary>Construindo uma plataforma de agentes com python</summary>
            <description>Criar um agente isolado em um Jupyter Notebook é fácil, mas colocá-lo em produção de forma confiável é um desafio de engenharia de software. Quando múltiplos agentes precisam colaborar, integrar dentro do seu produto interagindo com bases de dados e APIs a complexidade aumenta exponencialmente.

Nesta apresentação, discutiremos os bastidores da construção de uma plataforma de agentes utilizando Python. Vamos analisar padrões de arquitetura para comunicação entre agentes com o produto, gerenciamento de prompts, resiliência a falhas, além de estratégias cruciais de observabilidade (tracing) e controle de custos de tokens.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/WGZH7S/</url>
            <location>Esmeralda 2</location>
            
            <attendee>GUILHERME CARDOSO DE VARGAS</attendee>
            
            <attendee>Felipe Bizzo</attendee>
            
            <attendee>Lucas Seiki Oshiro</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HZAZDP@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HZAZDP</pentabarf:event-slug>
            <pentabarf:title>Raio X em tempo de execução:segurança máxima em Python Puro</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T155500</dtstart>
            <dtend>20261017T164000</dtend>
            <duration>004500</duration>
            <summary>Raio X em tempo de execução:segurança máxima em Python Puro</summary>
            <description>As funcionalidades relativamente novas de &quot;audit&quot; e &quot;monitoring&quot;, permitem a observabilidade direta de código Python em produção em um nível sem prescedentes, e que podem ser feitos de forma simples, com um mínimo de código (que pode ser reutilizado em todos os projetos de uma empresa). Python elevou suas capacidades de introspecção a novos patamares, que só podem ter equivalentes em outras linguagens com mecanismos externos. É possível ter callbacks para cada acesso a rede, arquivos e chamadas ao sistema: uma mudança de comportamento de um sistema após uma atualização por conta de, por exemplo, um ataque de injeção de dependência, ou outra forma de execução de código arbitrário, pode ser percebida imediatamente.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/HZAZDP/</url>
            <location>Esmeralda 2</location>
            
            <attendee>João Sebastião de Oliveira Bueno</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>EQPAZB@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-EQPAZB</pentabarf:event-slug>
            <pentabarf:title>Júnior a Staff+: evoluindo na carreira sem virar gerente</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T100000</dtstart>
            <dtend>20261017T104500</dtend>
            <duration>004500</duration>
            <summary>Júnior a Staff+: evoluindo na carreira sem virar gerente</summary>
            <description>Nessa palestra vou mostrar, em uma linguagem amigável a quem está começando a sua carreira, diferentes visões sobre as posições técnicas que vêm depois de Senior Engineer, mais conhecidas como Staff+ Engineers, e diferenciar as posições de gestão, contribuidor individual e liderança técnica. Vou falar sobre as principais atribuições e detalhar cada um dos comportamentos esperados de alguém nessa posição em relação a assuntos como comunicação, estratégia, influência e liderança. E o melhor é que você já pode (e deve) começar a aplicar essas dicas mesmo antes de ser um Staff+ Engineer.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/EQPAZB/</url>
            <location>Esmeralda 1</location>
            
            <attendee>Vinicius Mendes</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UH9GLT@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UH9GLT</pentabarf:event-slug>
            <pentabarf:title>A tecnologia precisa chegar onde normalmente ela não chega</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T140000</dtstart>
            <dtend>20261017T144500</dtend>
            <duration>004500</duration>
            <summary>A tecnologia precisa chegar onde normalmente ela não chega</summary>
            <description>O **Pyriferia** nasceu da ideia de que a tecnologia precisa chegar onde normalmente ela não chega.

Em vez de começar pela programação tradicional, o projeto utiliza games, vídeos, redes sociais, IA e cultura digital para criar conexão com jovens da periferia e introduzir conceitos de tecnologia de forma prática e acessível.

Nesta palestra, irei compartilhar a metodologia do projeto, experiências realizadas dentro da **Fundação CASA**, desafios, aprendizados e a visão de construir uma nova ponte entre periferia e tecnologia através da cultura digital.

**Uma apresentação sobre pertencimento, inovação social e o poder da comunidade Python em ampliar oportunidades reais através da tecnologia.**</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/UH9GLT/</url>
            <location>Esmeralda 1</location>
            
            <attendee>Brown</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>V3RAFY@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-V3RAFY</pentabarf:event-slug>
            <pentabarf:title>Arquitetura da hostilidade: elas não estão seguras na rede</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T145000</dtstart>
            <dtend>20261017T153500</dtend>
            <duration>004500</duration>
            <summary>Arquitetura da hostilidade: elas não estão seguras na rede</summary>
            <description>O objetivo é deslocar o debate da &#x27;segurança individual&#x27; (o que a mulher deve fazer para se proteger) para a &#x27;responsabilidade sistêmica&#x27;. Uma conversa necessária sobre limites da liberdade de expressão e a urgência de redes que não nos imponham o silêncio.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/V3RAFY/</url>
            <location>Esmeralda 1</location>
            
            <attendee>Laura Rodrigues</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3P73Y8@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3P73Y8</pentabarf:event-slug>
            <pentabarf:title>Construindo uma Cultura de Code Review</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T155500</dtstart>
            <dtend>20261017T164000</dtend>
            <duration>004500</duration>
            <summary>Construindo uma Cultura de Code Review</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/3P73Y8/</url>
            <location>Esmeralda 1</location>
            
            <attendee>Renan de Assis</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HS3BTL@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HS3BTL</pentabarf:event-slug>
            <pentabarf:title>PEP 810 (lazy imports): Apps melhores, +rápidos e +leves</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T100000</dtstart>
            <dtend>20261017T104500</dtend>
            <duration>004500</duration>
            <summary>PEP 810 (lazy imports): Apps melhores, +rápidos e +leves</summary>
            <description>Python é frequentemente considerada uma linguagem lenta. Mas e se pudéssemos melhorar a velocidade e consumo de memória, postergando o carregamento de coisas na memória (ou em alguns casos até mesmo não carregando elas)?

Nesta apresentação, apresentarei a PEP 810: lazy imports. Uma ideia antiga que foi reinventada e agora pode nos proporcionar melhor consumo de memória e tempos de inicialização mais rápidos para aplicações com Python 3.15 e posterior, utilizando uma nova palavra-chave reservada: `lazy`.

Mostrarei alguns exemplos dos casos de uso mais comuns, bem como cenários enfrentados por desenvolvedores, e como essa PEP deve ser usada na prática. Ao final desta apresentação, os participantes aprenderão mais sobre o consumo de memória em Python e como a PEP 810 pode melhorar isso.

A apresentação é voltada para pythonistas intermediários. Iniciantes com Python podem se sentir um pouco perdidos, então ter pelo menos 1 ou 2 anos de experiência com a linguagem é recomendado</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/HS3BTL/</url>
            <location>Topázio 2</location>
            
            <attendee>Vinícius Gubiani Ferreira</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7JYM97@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7JYM97</pentabarf:event-slug>
            <pentabarf:title>Django + Rust: criptografia transparente no banco de dados</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T140000</dtstart>
            <dtend>20261017T144500</dtend>
            <duration>004500</duration>
            <summary>Django + Rust: criptografia transparente no banco de dados</summary>
            <description>Criptografar dados sensíveis é não só uma boa prática de desenvolvimento, como uma exigência crescente por conta de leis como a LGPD e GDPR. No entanto, o que pode parecer simples mostra sua verdadeira face quando fazemos um `.filter()` no Django e notamos que nada está sendo retornado.

Esse é o coração dessa palestra, a _`queryability`_. Vamos dissecar três abordagens reais:

- criptografia determinística
- blind indexes via HMAC
- delegação ao banco com pgcrypto

Entendendo o que cada uma protege, o que cada uma expõe, e qual o custo em complexidade e performance. E eu já posso adiantar que não existe uma bala de prata.

Com esse mapa em mãos, a segunda parte explora uma direção experimental para o núcleo criptográfico: uma lib em Rust exposta ao Python via PyO3, aproveitando o ecossistema RustCrypto para operações em bulk com segurança de memória garantida em tempo de compilação.

Vamos ver como isso se integra como um Field customizado no Django e onde ainda há perguntas em aberto.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/7JYM97/</url>
            <location>Topázio 2</location>
            
            <attendee>Ricardo Morato Rocha</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XW7USL@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XW7USL</pentabarf:event-slug>
            <pentabarf:title>Implementando controle de Qualidade de Dados com Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20261017T145000</dtstart>
            <dtend>20261017T153500</dtend>
            <duration>004500</duration>
            <summary>Implementando controle de Qualidade de Dados com Python</summary>
            <description>Nesta palestra irei falar um pouco sobre o meu campo de atuação atual, a área de Data Quality. Irei explorar a sua importância, conceitos, técnicas e estratégias. Irei também falar sobre as principais ferramentas para implementação de data quality utilizando Python e irei explorar um use case real onde foi utilizado o Airflow para a implementação de verificações para garantir a qualidade de dados. Os principais conceitos envolvidos nesta palestra serão baseados no livro Fundamentos da Qualidade de Dados (Moses, Gavish e Vorwerck), porém outras referências bibliográficas também serão utilizadas.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/XW7USL/</url>
            <location>Topázio 2</location>
            
            <attendee>Rafael Calixto</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZZ9QUH@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZZ9QUH</pentabarf:event-slug>
            <pentabarf:title>Engenharia de Plataforma: quando seu cliente é dev</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261017T155500</dtstart>
            <dtend>20261017T164000</dtend>
            <duration>004500</duration>
            <summary>Engenharia de Plataforma: quando seu cliente é dev</summary>
            <description>Engenharia de Plataforma é um termo um tanto abrangente, e pode ser aplicado de muitas maneiras, dependendo do contexto da instituição onde está inserida.
Trabalho há pouco mais de um ano em um time de Engenharia de Plataforma que está iniciando suas atividades, e gostaria de compartilhar este case com vocês.
Existem muitas maneiras de fazer coisas certas ao se tratar de Engenharia de Plataforma, e ainda mais maneiras de fazer coisas erradas.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/ZZ9QUH/</url>
            <location>Topázio 2</location>
            
            <attendee>Ana Dulce</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SKKLDT@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SKKLDT</pentabarf:event-slug>
            <pentabarf:title>Diversidade Escalável como Infraestrutura de Resultados</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20261018T100000</dtstart>
            <dtend>20261018T104500</dtend>
            <duration>004500</duration>
            <summary>Diversidade Escalável como Infraestrutura de Resultados</summary>
            <description>Inclusão não é um valor abstrato, é uma decisão de arquitetura. Mais do que uma pauta, ela reflete o tipo de organização que escolhemos construir e sustentar ao longo do tempo. Falar de diversidade sem transformar estruturas é manter a inclusão no campo do discurso e esse é um caminho que já não se sustenta.

Nesta proposta, parto da ideia de que acessibilidade por design é um caminho sem volta. Em um cenário cada vez mais complexo, depender de capital social, networking e leitura implícita de contexto não apenas exclui, limita o potencial coletivo. Estruturas claras, previsíveis e acessíveis deixam de ser diferencial e passam a ser base e fonte de resultados.

A partir de exemplos práticos no contexto de tecnologia e desenvolvimento de software, exploro como documentação bem estruturada, processos explícitos e decisões transparentes aumentam autonomia, reduzem ambiguidades e elevam a qualidade das entregas.

No fim, não se trata apenas de incluir mais pessoas, mas de sustentar valores com consistência transformando diversidade em resultado real, performance e bem-estar de forma escalável.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/SKKLDT/</url>
            <location>Principal</location>
            
            <attendee>Camila Perroud</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VPLJDY@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VPLJDY</pentabarf:event-slug>
            <pentabarf:title>Fernando Masanori</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261018T111000</dtstart>
            <dtend>20261018T121000</dtend>
            <duration>010000</duration>
            <summary>Fernando Masanori</summary>
            <description>Fernando Masanori é professor da FATEC São José dos Campos e um dos pioneiros da comunidade Python brasileira. Formado em Computação pelo IME-USP e mestre pelo ITA, é criador do Python para Zumbis, iniciativa voltada ao ensino de Python e programação. É Fellow da Python Software Foundation e recebeu o Prêmio Dorneles Treméa, uma das homenagens da comunidade Python brasileira.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://talks.python.org.br/pybr26/talk/VPLJDY/</url>
            <location>Principal</location>
            
            <attendee>Fernando Masanori Ashikaga</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PPST3L@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PPST3L</pentabarf:event-slug>
            <pentabarf:title>Painel Python Floripa 100: Vida Longa às Comunidades Tech</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261018T140000</dtstart>
            <dtend>20261018T144500</dtend>
            <duration>004500</duration>
            <summary>Painel Python Floripa 100: Vida Longa às Comunidades Tech</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/PPST3L/</url>
            <location>Principal</location>
            
            <attendee>Rodrigo Bastos Vieira</attendee>
            
            <attendee>Glória Barboza</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>GENHBX@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-GENHBX</pentabarf:event-slug>
            <pentabarf:title>Geisa Silva</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20261018T151000</dtstart>
            <dtend>20261018T161000</dtend>
            <duration>010000</duration>
            <summary>Geisa Silva</summary>
            <description>Educadora popular e Mestranda em Comunicação pelo POSCOM-UFBA, integrante dos grupos de pesquisa Gig@-UFBA e Meninas Digitais-BA, carpinteira do universo no [Raul Hacker Clube]([url](https://www.instagram.com/raulhackerclub/)) e desenvolvedora de projetos de infraestruturas para autonomia feminista na Coletiva Periféricas.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://talks.python.org.br/pybr26/talk/GENHBX/</url>
            <location>Principal</location>
            
            <attendee>Geisa Silva</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>D39SFK@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-D39SFK</pentabarf:event-slug>
            <pentabarf:title>Ataques de Supply Chain via Pip e Entry Points</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261018T100000</dtstart>
            <dtend>20261018T104500</dtend>
            <duration>004500</duration>
            <summary>Ataques de Supply Chain via Pip e Entry Points</summary>
            <description>Você confia no seu pip install? O ecossistema Python é um dos mais produtivos do mundo, mas essa facilidade de uso esconde vetores de ataque perigosos que subvertem a confiança entre desenvolvedor e ferramenta. Nesta palestra, vamos explorar tecnicamente como atacantes utilizam funcionalidades legítimas do Python — como setup.py, pyproject.toml e Entry Points — para executar código malicioso e ganhar persistência em ambientes de desenvolvimento, muitas vezes antes mesmo de um import ser executado.

Analisaremos cenários reais de Typosquatting e Dependency Confusion, demonstrando como um simples erro de digitação pode resultar em exfiltração de segredos e chaves de API. Mais do que apenas apontar o problema, discutiremos estratégias modernas de defesa, desde o uso de ferramentas de auditoria como pip-audit até a implementação de práticas de &#x27;Zero Trust&#x27; no fluxo de desenvolvimento. Venha entender por que o seu laptop é hoje o alvo favorito do Red Team e como blindar sua cadeia de suprimentos.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/D39SFK/</url>
            <location>Esmeralda 2</location>
            
            <attendee>Lucas Lemes</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3GU8KM@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3GU8KM</pentabarf:event-slug>
            <pentabarf:title>Liderança Intencional</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261018T140000</dtstart>
            <dtend>20261018T144500</dtend>
            <duration>004500</duration>
            <summary>Liderança Intencional</summary>
            <description>Liderar pessoas é equilibrar as necessidades pessoais e de carreira do time com os resultados e expectativas da empresa.
Nesta palestra, compartilho conceitos, experiências e ferramentas práticas sobre como estruturar a comunicação, conduzir 1:1s mais efetivas, fortalecer a segurança psicológica e construir relações mais sólidas dentro da equipe, tornando esse equilíbrio mais natural e promovendo resultados com uma abordagem humanizada. O conteúdo explora maneiras de desenvolver pessoas, aumentar o engajamento e criar ambientes em que performance e bem-estar caminhem juntos
A partir de experiências reais de gestão, trarei métodos que aplico com meus times para estimular motivação, fortalecer a confiança e potencializar o melhor de cada pessoa, sem recorrer a uma cultura baseada apenas em pressão excessiva e cobranças sem suporte que sustente. Uma conversa sobre liderança consciente, atitudes com propósito e estratégias que valorizam resultados sem abrir mão do lado humano.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/3GU8KM/</url>
            <location>Esmeralda 2</location>
            
            <attendee>Debs Atanes</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>E8BWWK@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-E8BWWK</pentabarf:event-slug>
            <pentabarf:title>Quando fica pronto? Como prever entrega de software</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261018T100000</dtstart>
            <dtend>20261018T104500</dtend>
            <duration>004500</duration>
            <summary>Quando fica pronto? Como prever entrega de software</summary>
            <description>Estimar software com base em &quot;chute&quot; ou Story Points costuma ser um exercício de frustração. Mas e se pudéssemos usar o histórico do seu time para prever o futuro com confiança estatística, tanto para um item quanto para vários, com Python?</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/E8BWWK/</url>
            <location>Topázio 2</location>
            
            <attendee>Rodrigo Bastos Vieira</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>USZCFC@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-USZCFC</pentabarf:event-slug>
            <pentabarf:title>Python + Temporal: O Core de Workflows Modernos</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261018T140000</dtstart>
            <dtend>20261018T144500</dtend>
            <duration>004500</duration>
            <summary>Python + Temporal: O Core de Workflows Modernos</summary>
            <description>Todo código que conversa com o mundo externo precisa lidar com falhas: timeouts, APIs fora do ar, processos que reiniciam no meio da execução. Com o tempo, a lógica de negócio fica soterrada por retries, tabelas de status, filas e crons.

O Temporal resolve isso com Durable Execution: cada passo do workflow é persistido e, se algo falhar, a execução retoma exatamente de onde parou. Você escreve o caminho feliz e a plataforma cuida de retries, estado, timers e recuperação.

O SDK Python usa recursos que você já conhece, como decorators, asyncio, type hints e Pydantic, e se integra facilmente ao que você já tem: FastAPI, bibliotecas existentes, bancos e APIs. A partir dessa base surgem padrões poderosos: SAGA com compensação automática, aprovação humana no meio do fluxo, agendamentos no lugar do cron e agentes de IA que não perdem o progresso quando algo cai.

Nesta palestra, veremos os conceitos, como o Temporal recupera um workflow após uma falha e aplicações reais em automação de redes, IA, testes automatizados e processos de negócio, além de como ele se posiciona em relação a ferramentas como Celery e Airflow.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestra</category>
            <url>https://talks.python.org.br/pybr26/talk/USZCFC/</url>
            <location>Topázio 2</location>
            
            <attendee>Adilson Torres Gregório de Souza</attendee>
            
        </vevent>
        
    </vcalendar>
</iCalendar>
