<?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>JETQDS@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JETQDS</pentabarf:event-slug>
            <pentabarf:title>Da idéia ao deploy com Plone</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251021T090000</dtstart>
            <dtend>20251021T160000</dtend>
            <duration>7.00000</duration>
            <summary>Da idéia ao deploy com Plone</summary>
            <description>O Plone é um sistema de gestão de conteúdo, escrito em Python, seguro, flexível e escalável. Seja o seu blog pessoal, uma intranet para sua organização, ou um portal de governo com mais de 40 milhões de usuários únicos diários, essa é a solução.
Nesse tutorial você verá todo o ciclo de vida de um novo projeto, desde a sua criação, escolha de funcionalidades, configuração de CI/CD, criação de imagens para containers e o deploy em um ambiente remoto.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Long tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/JETQDS/</url>
            <location>Impacta - Sala 201</location>
            
            <attendee>Érico Andrei</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HBACXP@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HBACXP</pentabarf:event-slug>
            <pentabarf:title>AWS VIBE CODING DOJO: Programação Colaborativa + IA! 👥</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251021T140000</dtstart>
            <dtend>20251021T173000</dtend>
            <duration>3.03000</duration>
            <summary>AWS VIBE CODING DOJO: Programação Colaborativa + IA! 👥</summary>
            <description>O AWS Vibe Coding Dojo é uma experiência imersiva de até 3 horas que combina programação colaborativa com inteligência artificial generativa. Os participantes trabalharão em equipe para desenvolver soluções reais utilizando o Amazon Q Developer CLI, explorando como os assistentes de IA estão revolucionando o processo de desenvolvimento de software.

A sessão é estruturada como um dojo colaborativo onde o projeto a ser desenvolvido é definido coletivamente pelo grupo, promovendo engajamento e aprendizado prático. Os participantes terão acesso direto às ferramentas mais recentes da AWS para IA generativa, com mentoria de especialistas para orientar o desenvolvimento e resolver desafios técnicos em tempo real.

Esta atividade oferece uma oportunidade única de vivenciar o futuro do desenvolvimento de software, combinando networking, aprendizado hands-on e resolução colaborativa de problemas. Ideal para desenvolvedores que desejam explorar as possibilidades da programação assistida por IA em um ambiente dinâmico e interativo.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/HBACXP/</url>
            <location>Impacta - Sala 202</location>
            
            <attendee>Marcelo Palladino</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XV8B8D@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XV8B8D</pentabarf:event-slug>
            <pentabarf:title>Orientação a Objetos com Python do Zero</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251021T090000</dtstart>
            <dtend>20251021T123000</dtend>
            <duration>3.03000</duration>
            <summary>Orientação a Objetos com Python do Zero</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/XV8B8D/</url>
            <location>Impacta - Sala 203</location>
            
            <attendee>Marcos Rocha</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>URYJ8F@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-URYJ8F</pentabarf:event-slug>
            <pentabarf:title>Testes automatizados com Python, Pytest e Playwright</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251021T140000</dtstart>
            <dtend>20251021T173000</dtend>
            <duration>3.03000</duration>
            <summary>Testes automatizados com Python, Pytest e Playwright</summary>
            <description>Em um time ágil, a Qualidade de Software é responsabilidade de todo o time e acontece em diferentes momentos do ciclo de desenvolvimento do software. Nesse tutorial vou fazer um overview dos quadrantes de Agile Testing, para ensinar onde acontece cada tipo de teste e ensinar como automatizar testes que seguem o fluxo de um usuário com Python, Pytest e Playwright.

Vou ensinar como utilizar Pytest fixtures para deixar os testes automatizados mais dinâmicos e como criar um plugin do Pytest. Também vou ensinar como utilizar o plugin pytest fornecido pelo Playwright chamado pytest-playwright para navegar pela web e escrever testes de ponta à ponta.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/URYJ8F/</url>
            <location>Impacta - Sala 203</location>
            
            <attendee>Andressa Cabistani</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QDEVLS@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QDEVLS</pentabarf:event-slug>
            <pentabarf:title>Data Science Financeira: Python para Tomada de Decisões</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251021T140000</dtstart>
            <dtend>20251021T173000</dtend>
            <duration>3.03000</duration>
            <summary>Data Science Financeira: Python para Tomada de Decisões</summary>
            <description>Você já se perguntou como os dados podem ajudar a tomar decisões mais inteligentes no mercado financeiro? Neste minicurso de Data Science Financeira: Python para Tomada de Decisões, vamos explorar como a programação pode ser uma aliada poderosa para quem quer entender melhor investimentos, riscos e oportunidades. De forma prática e acessível, vamos aprender a manipular dados, criar visualizações e aplicar técnicas simples de análise com Python. Não é preciso ser um expert: a ideia é desmistificar a ciência de dados e mostrar como ela pode ser aplicada no dia a dia de quem quer tomar decisões mais conscientes no mundo das finanças.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/QDEVLS/</url>
            <location>Impacta - Sala 204</location>
            
            <attendee>Carla Sant&#x27;Ana</attendee>
            
            <attendee>Pedro Henrique Lima Xavier Dutra</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SNGCGW@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SNGCGW</pentabarf:event-slug>
            <pentabarf:title>Python com Microcontrolador</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251021T090000</dtstart>
            <dtend>20251021T123000</dtend>
            <duration>3.03000</duration>
            <summary>Python com Microcontrolador</summary>
            <description>Neste tutorial, você aprenderá os conceitos básicos de programação com MicroPython em placas ESP32 utilizando a plataforma BIPES. Voltado para iniciantes, o conteúdo abordará:

- Configuração do ambiente (BIPES + ESP32);
- Sintaxe básica do MicroPython;
- Projeto prático (ex: controle de LEDs, sensores simples);
- Vantagens da plataforma BIPES para educação e prototipagem;
- Programar um semáforo.

Como ex-aluno do projeto de capacitação tecnológica do MTST, trago uma abordagem acessível, focada em aplicações sociais e comunitárias da tecnologia. Ideal para quem deseja iniciar em IoT e automação sem complicações!</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/SNGCGW/</url>
            <location>Impacta - Sala 206</location>
            
            <attendee>Quenia Gouevia</attendee>
            
            <attendee>-</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SUFTPN@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SUFTPN</pentabarf:event-slug>
            <pentabarf:title>Análise geoespacial com Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251021T140000</dtstart>
            <dtend>20251021T173000</dtend>
            <duration>3.03000</duration>
            <summary>Análise geoespacial com Python</summary>
            <description>A análise de dados geográficos tem se tornado fundamental em diversas áreas, como planejamento urbano, gestão ambiental, agricultura de precisão e logística. Neste tutorial, será apresentado conceitos sobre como utilizar a linguagem de programação python para realizar a análise de dados com informações geográficas, o que é essencial para obter uma boa compreensão a cerca de dados georreferenciados, além de auxiliar na geração de hipóteses que podem ser extraídas a partir dessa análise.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/SUFTPN/</url>
            <location>Impacta - Sala 206</location>
            
            <attendee>Gesiel Lopes</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XU87HF@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XU87HF</pentabarf:event-slug>
            <pentabarf:title>Construa seu primeiro projeto de Aprendizado de Máquina</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251021T090000</dtstart>
            <dtend>20251021T123000</dtend>
            <duration>3.03000</duration>
            <summary>Construa seu primeiro projeto de Aprendizado de Máquina</summary>
            <description>O Aprendizado de Máquina (ML) está revolucionando diversas áreas, e dar os primeiros passos nessa jornada pode parecer desafiador. Neste tutorial, vamos desmistificar o processo e construir juntos um projeto simples de ML usando Python.

Exploraremos conceitos fundamentais, como preparação de dados, escolha do modelo e avaliação de desempenho, utilizando bibliotecas populares como Numpy, Pandas, Scikit-Learn e Matplotlib. Após implementar o projeto prático, o aluno sairá deste tutorial com o conhecimento necessário para criar seu próprio modelo e continuar explorando a área de Aprendizado de Máquina. 

Se você tem curiosidade sobre IA e deseja aprender na prática, esta palestra é para você!

Tarefa:
Fazer predição da quantidade de gás carbônico emitido de acordo com as características do modelo do carro.

Modelos Utilizados:
- Regressão Linear
- Árvore de Decisão
Métricas:
- Erro médio quadrático
- R2
Bibliotecas utilizadas:
- Scikit-Learn
- Pandas
- Numpy
- Matplotlib
Roteiro:
1. Carregar conjunto de dados
2. Análise exploratória dos dados
3. Pré-processamento dos dados
3.1 Separar atributos e alvo
3.2 Dividir dados de treino e teste
4. Criar modelo de Regresssão Linear
5. Criar modelo de Árvore de Decisão
6. Comparar modelos
7. Visualizar dados</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/XU87HF/</url>
            <location>Impacta - Sala 208</location>
            
            <attendee>WESIN RIBEIRO ALVES</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WKQ33R@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WKQ33R</pentabarf:event-slug>
            <pentabarf:title>Documentar é só o começo!</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251021T140000</dtstart>
            <dtend>20251021T173000</dtend>
            <duration>3.03000</duration>
            <summary>Documentar é só o começo!</summary>
            <description>Você escreveu aquele pacote Python incrível, mas ainda está com um README.md sofrido e nenhum site de documentação? Calma, que **documentar é só o começo** — e você vai ver que é mais fácil (e mais bonito) do que parece.

Neste tutorial, você vai aprender, passo a passo, como criar um site de documentação profissional para o seu projeto Python. A jornada começa com o básico de **Git e GitHub**, passa pela estrutura de pastas, e vai até o deploy automático no **GitHub Pages** usando **GitHub Actions** ou **ReadTheDocs**.

Vamos explorar duas ferramentas populares de documentação:

- **Sphinx**, com direito a temas personalizados como o Furo e Read the Docs;
- **MkDocs**, incluindo o tema Material for MkDocs.

Além disso, você vai entender como escrever sua documentação em Markdown ou reStructuredText, como configurar arquivos como `conf.py` ou `mkdocs.yml`, e como deixar tudo integrado ao seu fluxo de desenvolvimento.

No final, seu projeto vai ter um site bonito, funcional e hospedado automaticamente, pronto pra impressionar colegas, recrutadores e até o seu eu do futuro.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/WKQ33R/</url>
            <location>Impacta - Sala 208</location>
            
            <attendee>Melissa Weber Mendonça</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JRKVAK@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JRKVAK</pentabarf:event-slug>
            <pentabarf:title>ML Engineering na Prática: Combinando Kedro com MLFlow</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251022T090000</dtstart>
            <dtend>20251022T160000</dtend>
            <duration>7.00000</duration>
            <summary>ML Engineering na Prática: Combinando Kedro com MLFlow</summary>
            <description>A Engenharia de Machine Learning envolve mais do que apenas treinar modelos em larga escala: exige pipelines organizados, eficientes e reproduzíveis, que permitam levar modelos desde o ambiente experimental até a produção. Neste tutorial prático, você aprenderá como combinar duas ferramentas poderosas—Kedro e MLflow—para criar pipelines robustos e eficientes, de ponta a ponta.

Com o Kedro, estruturaremos projetos de dados de forma modular, passando pela ingestão e tratamento inicial até as etapas de modelagem, validação e seleção dos melhores modelos. Em paralelo, utilizaremos o MLflow para garantir o rastreamento detalhado dos experimentos, permitindo o registro automático de parâmetros, métricas e versões dos modelos criados.

Ao longo da atividade, os participantes construirão passo a passo um pipeline baseado em um caso prático real, aplicando conceitos essenciais de engenharia de ML em um ambiente guiado e colaborativo. Ao final, terão uma base sólida para começar a utilizar essas ferramentas em suas próprias rotinas profissionais, facilitando a criação de projetos que sigam as boas práticas de ML.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Long tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/JRKVAK/</url>
            <location>Impacta - Sala 201</location>
            
            <attendee>Gustavo Mendonça Ferratti</attendee>
            
            <attendee>Caroline Dartora Burkoski Zago</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>YEKX9Q@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-YEKX9Q</pentabarf:event-slug>
            <pentabarf:title>Criando um framework Web de brinquedo só com Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251022T090000</dtstart>
            <dtend>20251022T160000</dtend>
            <duration>7.00000</duration>
            <summary>Criando um framework Web de brinquedo só com Python</summary>
            <description>Nesse tutorial serão apresentados diversos conceitos relacionados à Web, seus protocolos e abstrações. Conceitos como Resources (Documents), URL, representação (mime-types), requests, responses, etc serão destrinchados de de um nível conceitual até a sua implementação prática.

Esse tutorial nasceu da minha experiência com a construção do projeto Toy (https://github.com/osantana/toy) que foi criado para o evento Just Python mas também acrescenta debates sobre sistemas Hipermídia, minha apresentação sobre &quot;A Web é uma API&quot; (https://osantana.me/palestras/a-web-e-uma-api/), e o desenvolvimento do projeto Pactum (https://github.com/pactum-org/pactum).</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Long tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/YEKX9Q/</url>
            <location>Impacta - Sala 202</location>
            
            <attendee>Osvaldo Santana Neto</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3NTJ9K@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3NTJ9K</pentabarf:event-slug>
            <pentabarf:title>Pipelines de dados com Airflow</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251022T090000</dtstart>
            <dtend>20251022T123000</dtend>
            <duration>3.03000</duration>
            <summary>Pipelines de dados com Airflow</summary>
            <description>Este tutorial introdutório ao Apache Airflow é voltado para pessoas desenvolvedoras que já possuem experiência com Python e manipulação de dados e desejam entender como estruturar e automatizar fluxos de trabalho de dados. O objetivo é apresentar os conceitos fundamentais de pipelines de dados, discutir a importância da orquestração desses processos e explorar o funcionamento do Airflow como ferramenta central nesse contexto. Os participantes irão aprender como o Airflow organiza tarefas em DAGs (grafos acíclicos direcionados), como escrever suas próprias DAGs em Python, como escrever testes automatizados para o airflow, como monitorar execuções via interface web e algumas boas práticas para manter pipelines escaláveis, legíveis e robustos.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/3NTJ9K/</url>
            <location>Impacta - Sala 203</location>
            
            <attendee>Edson Bomfim</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PVXV33@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PVXV33</pentabarf:event-slug>
            <pentabarf:title>Criando aplicações de linha de comando amáveis</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251022T140000</dtstart>
            <dtend>20251022T173000</dtend>
            <duration>3.03000</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.
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>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/PVXV33/</url>
            <location>Impacta - Sala 203</location>
            
            <attendee>Álvaro Justen</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BKJDUV@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BKJDUV</pentabarf:event-slug>
            <pentabarf:title>Python nas Nuvens: Validando Infraestrutura AWS com Código</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251022T090000</dtstart>
            <dtend>20251022T123000</dtend>
            <duration>3.03000</duration>
            <summary>Python nas Nuvens: Validando Infraestrutura AWS com Código</summary>
            <description>Testar uma aplicação é importante. Mas e a infraestrutura que a sustenta? Nesta oficina vamos explorar o universo dos testes voltados para Infraestrutura como Código (IaC), entendendo como é possível validar configurações de nuvem, identificar falhas de segurança antes do deploy e garantir que o ambiente esteja de acordo com o que foi planejado.

Vamos utilizar ferramentas como boto3, pytest e moto para consultar, testar e simular recursos da AWS de forma automatizada, além de integrar esses testes a pipelines com GitHub Actions. A oficina também trará um exemplo introdutório com CloudFormation para demonstrar o ciclo completo: provisionar, validar e automatizar.

Se você quer ir além dos testes convencionais e entender como garantir qualidade desde a base do seu sistema, essa oficina é pra você. Não precisa ter experiência prévia com DevOps ou cloud, apenas curiosidade e vontade de aprender algo novo.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/BKJDUV/</url>
            <location>Impacta - Sala 204</location>
            
            <attendee>Paula SIlva</attendee>
            
            <attendee>Maria Giovanna Sales</attendee>
            
            <attendee>Izabely Gama</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>DFTZHJ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-DFTZHJ</pentabarf:event-slug>
            <pentabarf:title>Ensinar Python com Alegria: Didática e Vocação Viva</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251022T090000</dtstart>
            <dtend>20251022T123000</dtend>
            <duration>3.03000</duration>
            <summary>Ensinar Python com Alegria: Didática e Vocação Viva</summary>
            <description>Este tutorial é um convite para quem deseja ensinar Python — seja em escolas, projetos sociais, comunidades, ou mesmo para amigas, filhos ou colegas de trabalho.

Com base em anos de experiência, vamos explorar:
- Técnicas didáticas que funcionam com iniciantes
- Erros comuns ao ensinar e como evitá-los
- Como cultivar um ambiente de aprendizado empático, leve e transformador

Será uma oficina prática e reflexiva. Vamos discutir:
- A importância da nossa história pessoal na forma como ensinamos
- O papel da alegria como ferramenta pedagógica para engajar aprendizes

Estratégias como:
- Teste de mesa (simulação de código passo a passo)
- Exercícios com feedback imediato
- Avaliação formativa focada no processo, não só no resultado

A proposta une uma pedagogia acessível com o coração de quem acredita que ensinar muda o mundo — começando por nós mesmos.
Tudo em um ambiente seguro, leve e sem julgamentos.
Porque ensinar, quando feito com intenção e alegria, é também um jeito de crescer.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/DFTZHJ/</url>
            <location>Impacta - Sala 206</location>
            
            <attendee>Fernando Masanori Ashikaga</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>FX8PS7@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-FX8PS7</pentabarf:event-slug>
            <pentabarf:title>Sktime: previsão de séries temporais (en/pt)</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251022T140000</dtstart>
            <dtend>20251022T173000</dtend>
            <duration>3.03000</duration>
            <summary>Sktime: previsão de séries temporais (en/pt)</summary>
            <description>O tutorial irá desde o básico do framework, até recursos mais avançados. Vamos passar pelo uso de modelos simples e uma revisão do framework. Mostraremos como fazer previsão probabilistica, além do uso de modelos globais e métodos de reconciliação hierarquica, muito relavantes em aplicações reais. O tutorial contará com a presença de core-devs da biblioteca, sendo uma ótima oportunidade para novos membros da comunidade open-source entenderem o funcionamento da biblioteca e como contribuir.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/FX8PS7/</url>
            <location>Impacta - Sala 206</location>
            
            <attendee>Felipe Angelim</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>KWVJ7T@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-KWVJ7T</pentabarf:event-slug>
            <pentabarf:title>Banco tá lento né? Vamo otimizar isso aí!</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251022T090000</dtstart>
            <dtend>20251022T123000</dtend>
            <duration>3.03000</duration>
            <summary>Banco tá lento né? Vamo otimizar isso aí!</summary>
            <description>Este tutorial vai te ensinar como analisar queries lentas, identificar estruturas de tabelas problemáticas, otimizá-las e mitigar problemas futuros. E o melhor de tudo? Usando nossa querida Django ORM (e uns brinquedinhos especiais).

- Como a Django ORM abstrai as interações com o banco de dados
- Otimizações básicas para o dia a dia
- N+1: Por que ainda falamos sobre ele?
- O estranho relacionamento do Postgres e o count()
- Diferença prática entre select_related e prefetch_related
- Indexação de Banco de Dados (BTree vs BRIN vs Hash)
- Plano de Execução de Queries (Ou: Como o Dalibo mudou minha vida)
- Transações e suas peculiaridades
- Estratégias de Cacheamento
- O parente distante: Particionamento de tabelas</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/KWVJ7T/</url>
            <location>Impacta - Sala 208</location>
            
            <attendee>Nilton Frederico Teixeira</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7X9U7H@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7X9U7H</pentabarf:event-slug>
            <pentabarf:title>Seu primeiro modelo de Machine Learning no Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251022T140000</dtstart>
            <dtend>20251022T173000</dtend>
            <duration>3.03000</duration>
            <summary>Seu primeiro modelo de Machine Learning no Python</summary>
            <description>Ensinarei o básico de análise de dados: importar bibliotecas, importar arquivo csv, como entender a estrutura do dataset e fazer alguns gráficos simples (histograma, gráfico de dispersão, etc).

Na sequência, explicaria o que é um modelo de Machine Learning e uma árvore de decisão. Não entraria no assunto de entropia ou gini, somente mostraria a estrutura e a lógica por trás do algoritmo (mais ou menos igual eu fiz neste post: https://estatsite.com.br/2016/06/11/1970/).

Treinaríamos um modelo, algo mais comum, como previsão de churn ou inadimplência, e eu explicaria a quem se interessasse um pouco mais da carreira em data science.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/7X9U7H/</url>
            <location>Impacta - Sala 208</location>
            
            <attendee>Yukio</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>8BTMJJ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-8BTMJJ</pentabarf:event-slug>
            <pentabarf:title>Primeiros Passos com Python para Mulheres Iniciantes</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251023T090000</dtstart>
            <dtend>20251023T160000</dtend>
            <duration>7.00000</duration>
            <summary>Primeiros Passos com Python para Mulheres Iniciantes</summary>
            <description>Este tutorial é voltado para mulheres iniciantes que nunca programaram e desejam aprender os fundamentos da programação com Python em um ambiente seguro, colaborativo e sem julgamentos. O conteúdo será conduzido por tutoras das PyLadies São Paulo, com linguagem acessível, ritmo acolhedor e espaço para perguntas à vontade. A proposta é ensinar conceitos essenciais — como variáveis, estruturas de repetição e listas — de forma prática, com exercícios aplicados ao cotidiano, utilizando Jupyter Notebook (via Google Colab).
Além disso, serão apresentados pequenos projetos com dados reais, reforçando a autonomia e mostrando que todas podem aprender a programar. Este tutorial é uma oportunidade para mulheres darem seu primeiro passo com confiança no universo da tecnologia.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Long tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/8BTMJJ/</url>
            <location>Impacta - Sala 202</location>
            
            <attendee>PyLadies São Paulo</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>9H8WW9@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-9H8WW9</pentabarf:event-slug>
            <pentabarf:title>Hackeando com Dados: Investigando a Privacidade em Ferramen</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251023T090000</dtstart>
            <dtend>20251023T123000</dtend>
            <duration>3.03000</duration>
            <summary>Hackeando com Dados: Investigando a Privacidade em Ferramen</summary>
            <description>A privacidade e a segurança de dados são desafios crescentes com a popularização das ferramentas baseadas em inteligência artificial, especialmente aquelas que sintetizam e imitam a voz humana com alto realismo. Neste tutorial, abordaremos, por meio de atividades práticas, como identificar, extrair e analisar possíveis vulnerabilidades e riscos relacionados à privacidade dos usuários em ferramentas populares de geração de voz por IA. Utilizaremos Python e bibliotecas específicas para realizar testes práticos de segurança, além de mostrar técnicas reais usadas para investigar e expor fragilidades que possam comprometer a privacidade dos usuários.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/9H8WW9/</url>
            <location>Impacta - Sala 203</location>
            
            <attendee>Nina da Hora</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NWKUD9@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NWKUD9</pentabarf:event-slug>
            <pentabarf:title>Primeiros passos com Padrões de Projeto (com TDD)</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251023T090000</dtstart>
            <dtend>20251023T123000</dtend>
            <duration>3.03000</duration>
            <summary>Primeiros passos com Padrões de Projeto (com TDD)</summary>
            <description>Se você se identifica com a música dos Tripylistas que diz &quot;já sei refatorar, ja sei tipar meu código, agora só me resta aplicar padrões de projeto&quot;, esse tutorial é pra você!

Entender orientação a objetos e técnicas de refatoração é essencial para deixar seu código Python bem estruturado, e você chegará muito longe com esses conhecimentos. Mas pode chegar um momento na vida de uma aplicação em que ela tem tantas linhas de código, contribuidores e responsabilidades, que é necessário dar o próximo passo na organização do projeto. 

Padrões de Projeto (Design Patterns) surgem como uma alternativa robusta a esse cenário. São estruturas de organização de código (geralmente orientado a objetos) focadas em resolver algum problema organizacional, que já foram validadas e estão documentadas.

Nesse tutorial vamos entender um pouco melhor sobre o conceito geral de Padrões de Projeto, e usar alguns desses padrões para melhorar códigos Python existentes através de uma refatoração guiada a testes (TDD).</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/NWKUD9/</url>
            <location>Impacta - Sala 204</location>
            
            <attendee>Vitor Buxbaum Orlandi</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NBVB3R@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NBVB3R</pentabarf:event-slug>
            <pentabarf:title>Testes automatizados e qualidade de dados em data pipelines</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251023T140000</dtstart>
            <dtend>20251023T173000</dtend>
            <duration>3.03000</duration>
            <summary>Testes automatizados e qualidade de dados em data pipelines</summary>
            <description>Neste tutorial vamos aprender a como desenvolver testes automatizados e de qualidade de dados para construir pipeline de dados sem erros e com entrega de dados mais confiáveis. Utilize o pytest para escrever testes unitários em funções, teste de integração entre diferentes componentes e testes de performance para escalabilidade. Use a great expectations para garantir regras de qualidade de dados como olhar se os dados estão completos e avaliar recência de dados.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/NBVB3R/</url>
            <location>Impacta - Sala 204</location>
            
            <attendee>talissa moura ayres</attendee>
            
            <attendee>Gabrielle Stephanie Pires Mestrinho</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZWA7F3@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZWA7F3</pentabarf:event-slug>
            <pentabarf:title>Começando com FastAPI: construa sua primeira API em Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251023T090000</dtstart>
            <dtend>20251023T123000</dtend>
            <duration>3.03000</duration>
            <summary>Começando com FastAPI: construa sua primeira API em Python</summary>
            <description>🚀 Quer aprender a criar sua primeira API com Python? Neste tutorial introdutório, vamos explorar o **FastAPI**, um dos frameworks mais modernos e rápidos para construção de APIs REST.

🛠️ De forma prática e passo a passo, você vai aprender a:

- Criar seus primeiros endpoints (`GET`, `POST`)  
- Validar dados de entrada com **Pydantic**  
- Usar a documentação automática gerada pelo FastAPI  
- Testar sua API localmente com ferramentas simples  

👶 Este tutorial é ideal para quem está começando no mundo das APIs e quer entender os fundamentos do FastAPI para seguir evoluindo depois por conta própria.

🐍 Se você já programa em Python e quer dar seus primeiros passos com APIs web, esse tutorial é pra você!</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/ZWA7F3/</url>
            <location>Impacta - Sala 206</location>
            
            <attendee>Felipe de Morais🤴🏾</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RHTZKT@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RHTZKT</pentabarf:event-slug>
            <pentabarf:title>Unlocking the Power of LLMs: Creating RAG Applications</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251023T140000</dtstart>
            <dtend>20251023T173000</dtend>
            <duration>3.03000</duration>
            <summary>Unlocking the Power of LLMs: Creating RAG Applications</summary>
            <description>Large Language Models (LLMs) have revolutionized the field of natural language processing, but their true potential lies in their ability to be integrated into real-world applications. In this talk, we&#x27;ll explore the power of Retrieval-Augmented Generation (RAG) models, which combine the strengths of LLMs with the flexibility of retrieval-based approaches. We&#x27;ll delve into the design and implementation of RAG models, discussing the benefits and challenges of using pre-trained LLMs as a foundation. Through a hands-on example, we&#x27;ll demonstrate how to build a RAG model that can be applied to a variety of real-world problems, from text generation to question-answering. By the end of this talk, attendees will gain a deeper understanding of how to unlock the full potential of LLMs and create practical, effective RAG models that drive business value.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/RHTZKT/</url>
            <location>Impacta - Sala 206</location>
            
            <attendee>David Camacho</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NKE7VG@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NKE7VG</pentabarf:event-slug>
            <pentabarf:title>Exploring 2D and 3D geometry libraries in Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251023T090000</dtstart>
            <dtend>20251023T123000</dtend>
            <duration>3.03000</duration>
            <summary>Exploring 2D and 3D geometry libraries in Python</summary>
            <description>How can Python assist you with 2D and 3D geometry? What tools are available to create, transform, and manipulate such geometries? Can we use these tools to build creative visualizations?

Python has much to say about these questions. In this talk, we will explore the many features of the Python libraries shapely (for 2D geometries) and trimesh (for 3D geometries).

shapely and trimesh are industrial strength libraries used in general, geospatial, and scientific applications. shapely being a dependency of widely used GeoDataFrame library geopandas, and trimesh being used by Ultimaker-Cura, slicing models for 3D printing.

We will learn about 2D and 3D affine transformations, extrusions, boolean operations, and more. Through these lessons, you will see how these tools can be orchestrated to build arbitrarily complex 2D and 3D shapes. Once constructed, these 2D and 3D shapes can be visualized with the creative coding library py5.

In summary, this tutorial will teach you how shapely, trimesh, and py5 can work together to create beautiful visualizations of 2D and 3D geometry.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/NKE7VG/</url>
            <location>Impacta - Sala 208</location>
            
            <attendee>Alexandre B A Villares</attendee>
            
            <attendee>Jim Schmitz</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HCKQST@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HCKQST</pentabarf:event-slug>
            <pentabarf:title>Beyond the Basics: Data Visualization in Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251023T140000</dtstart>
            <dtend>20251023T173000</dtend>
            <duration>3.03000</duration>
            <summary>Beyond the Basics: Data Visualization in Python</summary>
            <description>The human brain excels at finding patterns in visual representations, which is why data visualizations are essential to any analysis. Done right, they bridge the gap between those analyzing the data and those consuming the analysis. However, learning to create impactful, aesthetically-pleasing visualizations can often be challenging. This session will equip you with the skills to make customized visualizations for your data using Python.

While there are many plotting libraries to choose from, the prolific Matplotlib library is always a great place to start. Since various Python data science libraries utilize Matplotlib under the hood, familiarity with Matplotlib itself gives you the flexibility to fine tune the resulting visualizations (e.g., add annotations, animate, etc.). This session will also introduce interactive visualizations using HoloViz, which provides a higher-level plotting API capable of using Matplotlib and Bokeh (a Python library for generating interactive, JavaScript-powered visualizations) under the hood.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Short tutorial</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/HCKQST/</url>
            <location>Impacta - Sala 208</location>
            
            <attendee>Stefanie Molin</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>TSRCZN@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-TSRCZN</pentabarf:event-slug>
            <pentabarf:title>Fabio Kon</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T110000</dtstart>
            <dtend>20251024T120000</dtend>
            <duration>1.00000</duration>
            <summary>Fabio Kon</summary>
            <description>Fabio Kon é Professor Titular de Ciência da Computação no IME-USP e suas áreas de pesquisa são Engenharia de Software, Cidades Inteligentes, Ciência de Dados e Empreendedorismo Digital. Fabio é autor de cerca de 200 artigos em periódicos e congressos nacionais e internacionais, foi coordenador do Instituto Nacional de Ciência e Tecnologia da Internet do Futuro para Cidades Inteligentes (http://interscity.org) e diretor da Open Source Initiative. Fabio é membro da SBC e Editor Associado da revista Communications of the ACM. É autor de cursos abertos de Introdução à Ciência da Computação com Python com mais de 250 mil matriculados. Atualmente, tem se preocupado com a qualidade do código gerado por LLMs e os potenciais impactos negativos na indústria de software e na sociedade.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/TSRCZN/</url>
            <location>Non-technical</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>F8CHC9@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-F8CHC9</pentabarf:event-slug>
            <pentabarf:title>Como ingressar na carreira 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>20251024T133000</dtstart>
            <dtend>20251024T141500</dtend>
            <duration>0.04500</duration>
            <summary>Como ingressar na carreira de dados com Python</summary>
            <description>A área de dados tem apresentado um crescimento de maneira exponencial. A necessidade de novos profissionais é ainda muito alta, com muitas ofertas de vagas em aberto. Porém como ingressar nesta carreira? Quais os requisitos, como saber o que é esperado de um profissional? 
É importante saber procurar a vaga que deseja atuar para se preparar melhor. Saber a perspectiva salarial e como acompanhar, ferramentas, e o principal, como se preparar para as entrevistas práticas.
Pois não adianta ter uma ótima capacidade técnica se não souber demonstrar isto para os outros. Trabalhar com dados é se envolver com as informações que estão sendo analisadas e propor novos insights não antes imaginados, é descobrir o novo.
Apesar do segmento ainda estar em alta daqui a alguns anos o mercado pode estar saturado então o momento de mergulhar nos dados é agora.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/F8CHC9/</url>
            <location>Non-technical</location>
            
            <attendee>Marino Hilário Catarino</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SDHF8L@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SDHF8L</pentabarf:event-slug>
            <pentabarf:title>PJ x CLT x Autônomo: como analisar uma proposta profissiona</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T142000</dtstart>
            <dtend>20251024T150500</dtend>
            <duration>0.04500</duration>
            <summary>PJ x CLT x Autônomo: como analisar uma proposta profissiona</summary>
            <description>A palestra se propõe a abordar de maneira objetiva quais pontos precisam ser ponderados ao receber propostas profissionais em diferentes modalidades de contratação, quais ressalvas é preciso ter para entender quando realmente é vantajoso seguir por uma delas, sempre buscando entender a realidade do profissional no mercado e priorizando sua segurança financeira e profissional em um meio tão volátil.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/SDHF8L/</url>
            <location>Non-technical</location>
            
            <attendee>Bruna Soares</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HRNGDL@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HRNGDL</pentabarf:event-slug>
            <pentabarf:title>Ensino de Programação para comunidades</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T151000</dtstart>
            <dtend>20251024T155500</dtend>
            <duration>0.04500</duration>
            <summary>Ensino de Programação para comunidades</summary>
            <description>Dizem que &quot;conhecimento é poder&quot;. Essa frase ganha ainda mais força dentro do PyLadies Manaus, uma comunidade que acredita no poder da educação como ferramenta de transformação pessoal, profissional e social.

Dentre tantas iniciativas, temos o Projeto Jyboia, uma ação realizada em parceria com o Global Shapers Community que tem como objetivo democratizar o ensino de programação. A atividade foi desenvolvida com crianças imigrantes e de comunidades periféricas de Manaus, utilizando uma abordagem lúdica como porta de entrada para o pensamento computacional.

A proposta é compartilhar aprendizados, desafios e resultados de uma experiência pedagógica que mostra na prática como a programação pode ser uma ponte para novas possibilidades, especialmente para grupos historicamente excluídos do acesso à tecnologia.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/HRNGDL/</url>
            <location>Non-technical</location>
            
            <attendee>Paula SIlva</attendee>
            
            <attendee>Mª Luana Pinheiro</attendee>
            
            <attendee>Nathiely Saraiva de Oliveira</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7XGPFB@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7XGPFB</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T163000</dtstart>
            <dtend>20251024T170000</dtend>
            <duration>0.03000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/7XGPFB/</url>
            <location>Non-technical</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>LFDAZE@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-LFDAZE</pentabarf:event-slug>
            <pentabarf:title>Robert Silva</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T170000</dtstart>
            <dtend>20251024T180000</dtend>
            <duration>1.00000</duration>
            <summary>Robert Silva</summary>
            <description>DevOps Engineer no Santander, com mais de 10 anos de experiência em TI como consultor e arquiteto de soluções. Especialista em Kubernetes e automação, certificado CKA e CKAD, é apaixonado por compartilhar conhecimento e inspirar profissionais na transição para DevOps.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/LFDAZE/</url>
            <location>Non-technical</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PBTNWX@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PBTNWX</pentabarf:event-slug>
            <pentabarf:title>Introdução ao Processamento de Linguagem Natural com Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T092000</dtstart>
            <dtend>20251024T100500</dtend>
            <duration>0.04500</duration>
            <summary>Introdução ao Processamento de Linguagem Natural com Python</summary>
            <description>Quer entender como ensinar a máquina a lidar com textos, palavras, gírias e até emojis? Nessa introdução prática ao Processamento de Linguagem Natural (PLN), vamos explorar como o Python pode ser usado para fazer com que computadores entendam linguagem humana. A ideia é apresentar os conceitos de forma leve e acessível, mostrando na prática como funcionam coisas como tokenização, limpeza de texto, contagem de palavras, análise de sentimentos e muito mais. Tudo isso usando ferramentas como nltk, spaCy e scikit-learn. Se você já sabe um pouco de Python e quer dar os primeiros passos no mundo do PLN, essa palestra é pra você!</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/PBTNWX/</url>
            <location>Beginner</location>
            
            <attendee>Ana Laura Berger dos Reis</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>DUKZMT@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-DUKZMT</pentabarf:event-slug>
            <pentabarf:title>Desenvolvimento SEM inteligência aritificial</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T101000</dtstart>
            <dtend>20251024T105500</dtend>
            <duration>0.04500</duration>
            <summary>Desenvolvimento SEM inteligência aritificial</summary>
            <description>Se você está lendo isso na grada da Python Brasil, é provável que hajam outras dezenas de palestras sobre como usar IA com Python, exemplos de integração com ChatGPT, e aplicações incríveis feitas baseadas no uso das mais diversas inteligências artificiais disponíveis no mercado.
E você talvez deva se perguntar (eu fiz isso), ainda é possível programar sem uso de IA? Meu objetivo está longe de ser uma crítica ao uso de IA, eu uso diariamente, mas trazer um pouco do gostinho de como faziam os maias e incas, quando usávamos livros, stack overflow, longas pesquisas no google e até mesmo pensar era tido como opção para solucionar nossos problemas!</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/DUKZMT/</url>
            <location>Beginner</location>
            
            <attendee>Tyrone Damasceno</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>C9ZUET@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-C9ZUET</pentabarf:event-slug>
            <pentabarf:title>Abrindo a Black-box: métodos para entender a IA</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T133000</dtstart>
            <dtend>20251024T141500</dtend>
            <duration>0.04500</duration>
            <summary>Abrindo a Black-box: métodos para entender a IA</summary>
            <description>Modelos de IA não precisam residir em caixas pretas! Existem diferentes técnicas que nos ajudam a compreender como suas predições são feitas e como isso afeta nossas decisões.

Dentre as diferentes técnicas disponíveis, podemos analisar como os métodos LIME, SHAP e Contrafactuais funcionam em diferentes contextos, além de explorar como essas explicações podem ser apresentadas aos usuários finais através de gráficos objetivos.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/C9ZUET/</url>
            <location>Beginner</location>
            
            <attendee>Guilherme Lourenço</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>FTKPVV@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-FTKPVV</pentabarf:event-slug>
            <pentabarf:title>IA generativa no setor de energia: agentes de IA em ação</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T142000</dtstart>
            <dtend>20251024T150500</dtend>
            <duration>0.04500</duration>
            <summary>IA generativa no setor de energia: agentes de IA em ação</summary>
            <description>A IA generativa está revolucionando diversos setores – e o de energia não fica de fora. Nesta palestra, vamos mostrar como Python e ferramentas modernas de IA (como o framework LangGraph) foram aplicados para construir agentes inteligentes que auxiliam distribuidoras de energia em tarefas complexas.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/FTKPVV/</url>
            <location>Beginner</location>
            
            <attendee>Gustavo Sacchi Silva</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VULNN7@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VULNN7</pentabarf:event-slug>
            <pentabarf:title>MKDocs Desvendado: Documentação Sem Complicações</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T151000</dtstart>
            <dtend>20251024T155500</dtend>
            <duration>0.04500</duration>
            <summary>MKDocs Desvendado: Documentação Sem Complicações</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/VULNN7/</url>
            <location>Beginner</location>
            
            <attendee>Dáviny Letícia Vidal</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7XGPFB@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7XGPFB</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T163000</dtstart>
            <dtend>20251024T170000</dtend>
            <duration>0.03000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/7XGPFB/</url>
            <location>Beginner</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>YBN3JE@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-YBN3JE</pentabarf:event-slug>
            <pentabarf:title>Busca Semântica com Python e Vertex AI</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T101000</dtstart>
            <dtend>20251024T105500</dtend>
            <duration>0.04500</duration>
            <summary>Busca Semântica com Python e Vertex AI</summary>
            <description>link do colab: https://colab.research.google.com/drive/1yad4daSdvAEfRWgh_D1QxZh7-5wE4nxR?usp=sharing

Como aplicar machine learning de forma prática para melhorar a vida de quem busca por decisões judiciais, súmulas e doutrinas em meio a mais de 1 bilhão de documentos? Nesta palestra, compartilho como estamos evoluindo a busca tradicional por palavras-chave para uma busca semântica baseada em vetores, utilizando Python e o Vertex AI Matching Engine.

Vou mostrar, com exemplos reais do nosso produto de pesquisa jurídica, como gerar embeddings, indexar documentos e realizar buscas mais inteligentes que entendem o contexto da consulta — mesmo quando o usuário não acerta nos termos exatos.

Além da parte técnica (com notebooks e código em Python), discuto os critérios de produto que nos levaram a explorar a busca vetorial, os desafios de relevância em linguagem jurídica, e como experimentamos com segurança em um ambiente de alta responsabilidade.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/YBN3JE/</url>
            <location>Intermediate</location>
            
            <attendee>Thais N Viana</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MBGSBK@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MBGSBK</pentabarf:event-slug>
            <pentabarf:title>Desvendando os dados do ENEM com Modelagem Multinível</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T133000</dtstart>
            <dtend>20251024T141500</dtend>
            <duration>0.04500</duration>
            <summary>Desvendando os dados do ENEM com Modelagem Multinível</summary>
            <description>O ENEM, Exame Nacional do Ensino Médio, é um pilar fundamental do sistema educacional brasileiro, servindo como principal porta de entrada para o ensino superior de milhões de estudantes. Com impressionantes 4,3 milhões de participantes apenas em 2024, os dados gerados pelo exame são uma verdadeira mina de ouro para compreender a complexidade da educação no Brasil. De desigualdades regionais a fatores socioeconômicos, os dados do ENEM oferecem uma janela valiosa para os desafios e oportunidades enfrentados pelos estudantes em todo o país.

Nesta palestra, vamos explorar o poder da Modelagem Multinível, uma técnica voltada para a análise de dados com estruturas hierárquicas - como estudantes dentro de escolas e escolas dentro de regiões. Ao olhar para os dados do ENEM com essa lente, vamos investigar questões-chave como: 1) De que forma o acesso à educação, a condição socioeconômica e as diferenças regionais impactam o sucesso dos alunos? 2) Quais são os principais fatores que determinam os resultados educacionais em um país tão diverso e complexo como o Brasil?

Começaremos explicando o conceito de modelagem multinível e como ele se aplica aos dados do ENEM. Em seguida, mergulharemos em exemplos reais, analisando tanto características individuais dos estudantes quanto influências em nível escolar. Essa abordagem nos ajuda a conectar fatores micro (nível do aluno) e macro (nível da escola e da região), oferecendo uma visão abrangente dos desafios educacionais brasileiros.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/MBGSBK/</url>
            <location>Intermediate</location>
            
            <attendee>Angelica Custodio</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ADL7GQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ADL7GQ</pentabarf:event-slug>
            <pentabarf:title>O projeto Gatorade Gx</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T142000</dtstart>
            <dtend>20251024T150500</dtend>
            <duration>0.04500</duration>
            <summary>O projeto Gatorade Gx</summary>
            <description>Nesta palestra falaremos da concepção, implementação e deploy do projeto Gatorade Gx em 2020 quando a gatorade lançou um adesivo que media a sudorese (nível de suor) e perda de sódio para atletas de alta performance. O projeto foi executado pela Work&amp;Co em NYC com participação de engenheiros de software brasileiros. O backend foi inteiramente desenvolvido em Python.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/ADL7GQ/</url>
            <location>Intermediate</location>
            
            <attendee>Rodrigo Dias Arruda Senra</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZQVDKH@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZQVDKH</pentabarf:event-slug>
            <pentabarf:title>HTMX e Django: desenvolvimento web moderno e descomplicado</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T151000</dtstart>
            <dtend>20251024T155500</dtend>
            <duration>0.04500</duration>
            <summary>HTMX e Django: desenvolvimento web moderno e descomplicado</summary>
            <description>Exploraremos como o HTMX aproveita os recursos muitas vezes esquecidos do Django, como seu robusto sistema de templates, tratamento de formulários e roteamento de URLs. Veremos na prática como criar interfaces dinâmicas e interativas sem abandonar o conforto do lado do servidor.
Tópicos abordados:

- O que o Django faz bem?
- Como podemos deixar essas aplicações mais dinâmicas?
- Evolução dos controles hipermídia, soluções no cliente e a ascenção de frameworks client-side
- HTMX como uma alternativa para aplicações hipermídia com foco no backend
- Quando usar HTMX versus frameworks client-side
- Exemplo prático com Django e HTMX (demonstração)

Ao final da palestra, você terá uma nova perspectiva sobre como criar aplicações web poderosas e compatíveis com REST, aproveitando ao máximo o ecossistema Django, e com um caminho viável para evoluir aplicações Django já existentes.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/ZQVDKH/</url>
            <location>Intermediate</location>
            
            <attendee>Rodrigo Bastos Vieira</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7XGPFB@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7XGPFB</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T163000</dtstart>
            <dtend>20251024T170000</dtend>
            <duration>0.03000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/7XGPFB/</url>
            <location>Intermediate</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PGVYHL@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PGVYHL</pentabarf:event-slug>
            <pentabarf:title>Adoção de tipos em um projeto com 25 anos de vida</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T092000</dtstart>
            <dtend>20251024T100500</dtend>
            <duration>0.04500</duration>
            <summary>Adoção de tipos em um projeto com 25 anos de vida</summary>
            <description>A adoção de tipagem na linguagem Python tem sido um dos tópicos mais polêmicos dos últimos anos, pricipalmente entre os desenvolvedores mais experientes e que reclamam do excesso de energia (e PEPs) investidos para que esse suporte seja mais completo.
A polêmica se torna quase um assunto proibido quando se trabalha em bases de código com longa história, que prezam pela estabilidade, mas que continuam em ativo desenvolvimento.
Pretendo, nessa apresentação, discutir o processo de decisão pela adoção, gradual, de tipagem em um projeto open source com mais de 25 anos de história e que foi contruído utilizando todas as vantagens apresentadas por uma linguagem de programação dinâmica.
Abordarei as inúmeras dificuldades, impossibilidades e, principalmente, as vantagens do uso de tipos em nosso projeto.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/PGVYHL/</url>
            <location>Advanced</location>
            
            <attendee>Érico Andrei</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>THZZ7B@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-THZZ7B</pentabarf:event-slug>
            <pentabarf:title>Orquestrando o Caos: Dominando Pipelines com Airflow</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T101000</dtstart>
            <dtend>20251024T105500</dtend>
            <duration>0.04500</duration>
            <summary>Orquestrando o Caos: Dominando Pipelines com Airflow</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/THZZ7B/</url>
            <location>Advanced</location>
            
            <attendee>Davi Campos</attendee>
            
            <attendee>André Tayer</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NWB38C@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NWB38C</pentabarf:event-slug>
            <pentabarf:title>Infra Self-Service: Autosserviço com Python e GitOps</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T133000</dtstart>
            <dtend>20251024T141500</dtend>
            <duration>0.04500</duration>
            <summary>Infra Self-Service: Autosserviço com Python e GitOps</summary>
            <description>Nesta palestra, vou compartilhar como transformamos um ambiente onde o processo de criação de infraestrutura era lento, manual e dependente do time de SRE, em uma solução de autosserviço que beneficia tanto devs quanto profissionais de infraestrutura.

A mudança foi dividida em três pilares: padronização de módulos Terraform, construção de pipelines GitOps seguras e criação de uma API em Python que recebe os dados do desenvolvedor, gera o código Terraform, cria um Merge Request e aciona todo o processo de aplicação da infraestrutura.
Com isso, desenvolvedores conseguem solicitar recursos com rapidez e autonomia, enquanto os SREs mantêm controle, padronização e segurança no provisionamento.

Se você quer entender como Python pode ser usado para automatizar processos de infraestrutura e melhorar a colaboração entre devs e ops, essa palestra é pra você.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/NWB38C/</url>
            <location>Advanced</location>
            
            <attendee>Alexandre Castro</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RNUF3L@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RNUF3L</pentabarf:event-slug>
            <pentabarf:title>Seu pip install custa caro? O Futuro do PyPI</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T142000</dtstart>
            <dtend>20251024T150500</dtend>
            <duration>0.04500</duration>
            <summary>Seu pip install custa caro? O Futuro do PyPI</summary>
            <description>O PyPI é essencial para nós, mas seu crescimento explosivo, impulsionado por milhões de arquivos binários (wheels), gera custos imensos e desafios de sustentabilidade, dependendo fortemente de patrocínios. Esta palestra mergulha nos &quot;custos invisíveis&quot; do pip install, explora os desafios técnicos por trás da hospedagem de pacotes em escala e discute soluções inovadoras – como sistemas de build modernos e caches distribuídos – para garantir um ecossistema Python mais robusto, eficiente e independente para todos nós no Brasil e no mundo.

O Python Package Index (PyPI) é o coração pulsante do nosso ecossistema, servindo bilhões de downloads diariamente. Usamos pip install sem pensar muito, mas por trás dessa simplicidade existe uma infraestrutura massiva com desafios crescentes. O PyPI hospeda hoje mais de 12 milhões de arquivos, com um crescimento exponencial impulsionado principalmente por _wheels_ (binários pré-compilados).</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/RNUF3L/</url>
            <location>Advanced</location>
            
            <attendee>Pablo Henrique Aguilar</attendee>
            
            <attendee>Alex Rios</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>U7MUZT@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-U7MUZT</pentabarf:event-slug>
            <pentabarf:title>Python Performático: APIs de Alta Performance</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T151000</dtstart>
            <dtend>20251024T155500</dtend>
            <duration>0.04500</duration>
            <summary>Python Performático: APIs de Alta Performance</summary>
            <description>Performance é um dos grandes desafios no desenvolvimento de software moderno. Mas o que realmente impacta a eficiência de um sistema? Nessa palestra, vamos explorar abordagens técnicas para otimização, desde princípios de execução de comandos Python até decisões arquiteturais que fazem a diferença na execução de aplicações.

Abordaremos temas essenciais como:
 * Características de execução do Python em comparação a outras linguagens
 * Compilação vs. Interpretação: impactos na performance
 * Estudos de caso, benchmarks e comparações reais
 * Estratégias de design de código para alta eficiência
 * Arquiteturas e boas práticas em Python para sistemas performáticos
 * Exemplos práticos e lições extraídas de aplicações do mundo real

Se você busca entender melhor como projetar software com foco em desempenho, essa palestra trará insights valiosos e aplicáveis no seu dia a dia!</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/U7MUZT/</url>
            <location>Advanced</location>
            
            <attendee>Rafael Ferreira</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7XGPFB@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7XGPFB</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251024T163000</dtstart>
            <dtend>20251024T170000</dtend>
            <duration>0.03000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/7XGPFB/</url>
            <location>Advanced</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RPZ3KL@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RPZ3KL</pentabarf:event-slug>
            <pentabarf:title>Cumbuca Dev: Fortalecendo o Open Source no Brasil</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T090000</dtstart>
            <dtend>20251025T094500</dtend>
            <duration>0.04500</duration>
            <summary>Cumbuca Dev: Fortalecendo o Open Source no Brasil</summary>
            <description>Esta palestra apresenta a trajetória da Cumbuca Dev como uma iniciativa que fomenta o Open Source no Brasil, com foco em inclusão e capacitação. Mostraremos nossos principais projetos, repositórios e a comunidade acolhedora que constrói conhecimento colaborativamente. Também falaremos sobre o curso gratuito &quot;GitHub Essentials&quot; e o livro &quot;Git e GitHub para humanos&quot;, que auxiliam quem deseja iniciar ou aprofundar sua experiência em projetos reais. O objetivo é inspirar e guiar todas as pessoas que querem participar, contribuindo para o crescimento da cultura Open Source no país.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/RPZ3KL/</url>
            <location>Non-technical</location>
            
            <attendee>Maria Antônia Maia</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ATYPZC@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ATYPZC</pentabarf:event-slug>
            <pentabarf:title>Por que comunidades locais (e presenciais) são importantes</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T095000</dtstart>
            <dtend></dtend>
            <duration>0.04500</duration>
            <summary>Por que comunidades locais (e presenciais) são importantes</summary>
            <description>Acessar conteúdo técnico de qualidade está muito mais simples que no passado. Eventos nacionais e internacionais disponibilizam suas palestras em vídeo, além de várias pessoas produzirem e divulgando gratuitamente conteúdo em seus vários canais. Essa facilidade democratizou muito a troca de conhecimento, já que pessoas distantes geograficamente ou sem condições financeiras, podem ter acesso a informações que antes seriam impossíveis de serem obtidas.

Porém, encontrar pessoas presencialmente também é uma maneira muito boa para aprender e ensinar, fazer novas amizades e ter contato com outras realidades. Mas quando se fala de eventos presenciais, muita gente imagina que é necessário uma grande organização, buscar patrocinadores, pagar um local, gastar dinheiro com brindes, comida, ter palestras, etc.. Isso não é verdade! Com um pouquinho de organização é possível se reunir e começar uma pequena comunidade local.

Nesta palestra vou falar um pouco da minha experiência organizando pequenos (e as vezes nem tão pequenos) encontros de comunidade e tentar convencer quem estiver assistindo a participar e/ou organizar um em sua região, dando dicas de passos simples que não tomam tanto tempo mas que podem ajudar a começar.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/ATYPZC/</url>
            <location>Non-technical</location>
            
            <attendee>Renne Rocha</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UARFLQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UARFLQ</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T103500</dtstart>
            <dtend>20251025T105500</dtend>
            <duration>0.02000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/UARFLQ/</url>
            <location>Non-technical</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>GHUTWF@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-GHUTWF</pentabarf:event-slug>
            <pentabarf:title>Daiane Santos</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T110000</dtstart>
            <dtend>20251025T120000</dtend>
            <duration>1.00000</duration>
            <summary>Daiane Santos</summary>
            <description>Graduada em geografia pela Faculdade Sumaré, estudante de Redes de Computadores e ativista de direitos digitais desde 2010, apaixonada por hardware e suas possibilidades. Trabalha como Analista de TI da Ação Educativa. Coordenadora da Rede comunitária Associação Casa dos Meninos, membro do comitê de Redes comunitárias desde 2020 e educadora em direitos digitais.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/GHUTWF/</url>
            <location>Non-technical</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SYMAAL@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SYMAAL</pentabarf:event-slug>
            <pentabarf:title>Acha Spyware – Democratizando a Análise Forense Consentida</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T133000</dtstart>
            <dtend>20251025T141500</dtend>
            <duration>0.04500</duration>
            <summary>Acha Spyware – Democratizando a Análise Forense Consentida</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/SYMAAL/</url>
            <location>Non-technical</location>
            
            <attendee>Thaly Sanches</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BSRGMQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BSRGMQ</pentabarf:event-slug>
            <pentabarf:title>Dominando Processos Seletivos</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T142000</dtstart>
            <dtend>20251025T150500</dtend>
            <duration>0.04500</duration>
            <summary>Dominando Processos Seletivos</summary>
            <description>Uma das maiores dificuldades para um programador conseguir um emprego é a compreensão de que um processo de recrutamento tem uma dinâmica única que nada se parece com a dinâmica do trabalho propriamente dito.

Em um processo de contratação é importante que o candidato entenda a necessidade de se vender e de demonstrar que ele é capaz de resolver os problemas que precisam ser resolvidos no contratante.

Entrar no processo com uma preparação prévia para todas as etapas é o segredo para se dar bem e sair de tudo isso com o emprego garantido.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/BSRGMQ/</url>
            <location>Non-technical</location>
            
            <attendee>Osvaldo Santana Neto</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>LGLQLU@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-LGLQLU</pentabarf:event-slug>
            <pentabarf:title>Devs 10x não existem, mas e times 10x?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T151000</dtstart>
            <dtend>20251025T155500</dtend>
            <duration>0.04500</duration>
            <summary>Devs 10x não existem, mas e times 10x?</summary>
            <description>Vamos começar pela má notícia: devs 10x não existem. Mas a boa notícia é que times 10x são reais, e o maior obstáculo para alcançá-los costuma ser algo chamado silos de conhecimento.

A pesquisa de 2024 feita pelo StackOverflow mostra, assustadoramente, que pelo menos 48% dos desenvolvedores se esbarram em silos pelo menos 1 a 2x por semana (29% chegam a mais de 10x por semana!). **Como ser performático quando grande parte da sua semana é tentando redescobrir a roda que alguém já descobriu, tá rodando com ela, e só não te contaram?** Quantas vezes você não se viu na situação de passar horas tentando resolver um problema, pra algum colegar falar *“ah! isso ai? eu tive que fazer também, sei como resolver….”*.

Silos não apenas travam a produtividade, como também afetam a satisfação do time e a evolução do produto. Eles reduzem a capacidade de entregar com qualidade e consistência.

Nesta palestra, vou compartilhar um pouco do que aprendi sobre como quebrar esses silos, tornando o conhecimento aberto e colaborativo dentro de equipes de desenvolvimento. Você vai ver como uma boa estratégia de documentação, comunicação e alinhamento pode ajudar a construir um time 10x, sem depender de um “dev super-herói”.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/LGLQLU/</url>
            <location>Non-technical</location>
            
            <attendee>Gabriela Cavalcante da Silva</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7XGPFB@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7XGPFB</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T163000</dtstart>
            <dtend>20251025T170000</dtend>
            <duration>0.03000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/7XGPFB/</url>
            <location>Non-technical</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VLKSJH@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VLKSJH</pentabarf:event-slug>
            <pentabarf:title>Keynote Sebastián Ramírez</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T170000</dtstart>
            <dtend>20251025T180000</dtend>
            <duration>1.00000</duration>
            <summary>Keynote Sebastián Ramírez</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/VLKSJH/</url>
            <location>Non-technical</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WMXJDZ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WMXJDZ</pentabarf:event-slug>
            <pentabarf:title>Elasticsearch - um banco para quem lida com textos</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T090000</dtstart>
            <dtend>20251025T094500</dtend>
            <duration>0.04500</duration>
            <summary>Elasticsearch - um banco para quem lida com textos</summary>
            <description>Ao longo dos anos, o Python demonstrou ser extremamente versátil, sendo utilizada em multiplas tarefas - de IA ate calculos simples. Tais tarefas, apesar de parecerem áreas distintas, possuem em comum a *utilização e manipulação de dados*. Manipular dados se tornou um grande desafio devido à imensa variedade e quantidade de informações disponíveis. Por conta disso, a escolha da melhor forma de armazenar esses dados tornou-se um passo essencial para o sucesso de qualquer solução tecnológica. 
Para encaminhar solucoes desse problema, Eric Redmond e seus colegas lançaram o famoso livro 7 Databases in 7 Weeks (7 Bancos de Dados em 7 Semanas), em que abordam as aplicaçoes desses 7 bancos de dados open-source em diferentes cenários. Inspirado por este livro, gostaria de discutir um banco que não é tratado no livro : Elasticsearch. 
O Elasticsearch, semelhante ao MongoDB, é um banco que armazena documentos , porém possui ferramentas especializadas de busca textual , graças ao apache lucene. É possível fazer diversas configurações de buscas, como configurar termos semelhantes; busca por bigrama e até mesmo busca utilizando correlação de cosseno (busca muito utilizado em aplicações de LLM).
Esta palestra apresentará o propósito de cada um desses bancos de dados, explicará como instalá-los e será demonstrado como conectá-los a uma aplicação Python - seja ela uma aplicação web (Django/FastAPI), de engenharia de dados (Airflow/Prefect) ou até mesmo um simples script. Com essa abordagem,</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/WMXJDZ/</url>
            <location>Beginner</location>
            
            <attendee>Guilherme Martins</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WHYMWL@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WHYMWL</pentabarf:event-slug>
            <pentabarf:title>Análise de Complexidade das Built-in Structures Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T095000</dtstart>
            <dtend>20251025T103500</dtend>
            <duration>0.04500</duration>
            <summary>Análise de Complexidade das Built-in Structures Python</summary>
            <description>Nesta apresentação, exploraremos a análise de complexidade computacional das principais built-in data structures do Python, como list, dict, set e tuple. Serão abordadas suas operações fundamentais — inserção, remoção, busca e acesso — juntamente com seus respectivos custos de tempo (time complexity) e, em alguns casos, uso de memória.
Através de exemplos práticos, discutiremos como essas estruturas se comportam internamente e quais decisões de design impactam sua eficiência.
O objetivo é capacitar o público a escolher a estrutura correta para cada situação, otimizando o desempenho de algoritmos e aplicações em Python.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/WHYMWL/</url>
            <location>Beginner</location>
            
            <attendee>SIMONE INGRID MONTEIRO GAMA</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UARFLQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UARFLQ</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T103500</dtstart>
            <dtend>20251025T105500</dtend>
            <duration>0.02000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/UARFLQ/</url>
            <location>Beginner</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>9LKF3K@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-9LKF3K</pentabarf:event-slug>
            <pentabarf:title>The Synergies of Art and Open Source Maintenance</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T133000</dtstart>
            <dtend>20251025T141500</dtend>
            <duration>0.04500</duration>
            <summary>The Synergies of Art and Open Source Maintenance</summary>
            <description>How can maintaining an open source project contribute to an artist’s art practice? How can an artist’s art practice productively guide the design and development of an open source project?

This talk will be about the synergies between maintaining the creative coding library py5 and my career as an artist. Both originated at the same time, and since the beginning, they have contributed to and guided each other’s evolution and growth. They are intimately connected and forever intertwined.

I’ll discuss these connections with specific coding examples and show how I designed py5 to enable me to do everything from exploring and prototyping ideas to creating large scale digital animations. I’ll also talk about what I see for the future of py5, where I want to go as an artist, and how both of these will continue to support each other and result in more creative coding contributions to share with the open source community.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/9LKF3K/</url>
            <location>Beginner</location>
            
            <attendee>Jim Schmitz</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RKYSBL@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RKYSBL</pentabarf:event-slug>
            <pentabarf:title>Olhos de Silício: O que o computador vê ao olhar para você</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T142000</dtstart>
            <dtend>20251025T150500</dtend>
            <duration>0.04500</duration>
            <summary>Olhos de Silício: O que o computador vê ao olhar para você</summary>
            <description>Câmeras estão presentes em vários lugares: celulares, webcams, câmeras de monitoramento, drones, carros… Com elas, nós, humanos, conseguimos ter um ponto de vista diferente do que nossos olhos, fixos em nossas cabeças, conseguem. Você pode ver se o seu pet está comendo a comida que você deixou para ele, ou se está fazendo bagunça, sem estar presente na mesma sala. Porém, isso vem com um fator limitante: você precisa estar olhando para a imagem que a câmera gerou para extrair a informação relevante.
E se você conseguisse criar um sistema que “olhasse para a imagem da câmera” por você? Graças aos avanços da computação, temos uma área chamada Visão Computacional, cujo foco é o desenvolvimento de sistemas de computadores capazes de “enxergar o mundo”, e extrair as mesmas informações que você, humano, gostaria.
No mundo de hoje, nós criamos verdadeiras máquinas com olhos, e usamos elas em uma vasta gama de tarefas que, antigamente, eram dependentes de olhos humanos.
Nessa palestra, você será introduzido a como esses olhos de silício funcionam, e como podemos criar sistemas que interpretam imagens do mundo real.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/RKYSBL/</url>
            <location>Beginner</location>
            
            <attendee>Vinicius Peixoto</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>GKQZEQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-GKQZEQ</pentabarf:event-slug>
            <pentabarf:title>Data Morph: A Cautionary Tale of Summary Statistics</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T151000</dtstart>
            <dtend>20251025T155500</dtend>
            <duration>0.04500</duration>
            <summary>Data Morph: A Cautionary Tale of Summary Statistics</summary>
            <description>Statistics do not come intuitively to humans; they always try to find simple ways to describe complex things. Given a complex dataset, they may feel tempted to use simple summary statistics like the mean, median, or standard deviation to describe it. However, these numbers are not a replacement for visualizing the distribution.

To illustrate this fact, researchers have generated many datasets that are very different visually, but share the same summary statistics. In this talk, I will discuss [Data Morph](https://github.com/stefmolin/data-morph), an open source package that builds on previous research using simulated annealing to perturb an arbitrary input dataset into a variety of shapes, while preserving the mean, standard deviation, and correlation to multiple decimal points. I will showcase how it works, discuss the challenges faced during development, and explore the limitations of this approach.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/GKQZEQ/</url>
            <location>Beginner</location>
            
            <attendee>Stefanie Molin</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7XGPFB@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7XGPFB</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T163000</dtstart>
            <dtend>20251025T170000</dtend>
            <duration>0.03000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/7XGPFB/</url>
            <location>Beginner</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QTEFYP@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QTEFYP</pentabarf:event-slug>
            <pentabarf:title>CPython, Python e sua aplicação de alto desempenho</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T090000</dtstart>
            <dtend>20251025T094500</dtend>
            <duration>0.04500</duration>
            <summary>CPython, Python e sua aplicação de alto desempenho</summary>
            <description>Aplicações de alto desempenho são geralmente implementadas em C/C++ permitindo utilizar recursos para memória compartilhada ou memória distribuída, como OpenMP e MPI, ou programação para GPGPUSs (GPUs de propósito geral) utilizando CUDA ou OpenCL. Muitos pacotes em Python fornecem acesso a estes recursos de forma rápida e eficiente. Mas como criar nossas próprias bibliotecas de funções C/C++ de forma a podermos utilizar estes recursos em Python? Nesta palestra apresentaremos, de forma resumida e com base em exemplos, como criar bibliotecas de funções simples e como utilizar CPython para acessar estes recursos. Exemplos baseados na implementação do problema de multiplicação de matrizes serão apresentados para mostrar estes recursos e testes de desempenho rápidos serão utilizados para comparar o desempenho com os recursos disponibilizados na biblioteca NumPy.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/QTEFYP/</url>
            <location>Intermediate</location>
            
            <attendee>Esbel Tomas Valero Orellana</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>DWS38E@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-DWS38E</pentabarf:event-slug>
            <pentabarf:title>Busca 3.0: RAG Agêntico com MCP, Python e Elasticsearch</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T095000</dtstart>
            <dtend>20251025T103500</dtend>
            <duration>0.04500</duration>
            <summary>Busca 3.0: RAG Agêntico com MCP, Python e Elasticsearch</summary>
            <description>A evolução das buscas chegou: de keywords (1.0) para semântica (2.0), agora entramos na era da Busca 3.0 com RAG Agêntico - onde agentes inteligentes não apenas recuperam informação, mas entendem contexto, executam análises e tomam decisões.
O que é Busca 3.0 - RAG Agêntico:

Busca 1.0: Keywords e índices invertidos
Busca 2.0: Embeddings e busca semântica
Busca 3.0: Agentes que entendem, processam e agem

Arquitetura MCP + RAG Agêntico:

Model Context Protocol como ponte entre LLMs e dados
Resources: dados expostos como contexto permanente
Tools: capacidades de execução e análise
Prompts: templates de interação reutilizáveis

Demonstração prática com dados de saúde:
Veremos um agente que transforma perguntas como &quot;Como está minha evolução física?&quot; em:

Queries temporais no Elasticsearch
Aggregations estatísticas automáticas
Correlações entre métricas
Visualizações e insights personalizados

Stack tecnológica detalhada:

FastMCP para servidor de protocolo
Elasticsearch como engine de busca e analytics
AsyncIO para operações concorrentes
Pydantic para validação de schemas
JSON-RPC para comunicação LLM-servidor

Por que isso muda tudo:
RAG tradicional é passivo - apenas recupera. RAG Agêntico com MCP é ativo - entende intenção, executa lógica complexa e gera insights. É a diferença entre &quot;buscar documentos sobre exercícios&quot; e &quot;analisar meus padrões de atividade e sugerir melhorias&quot;.
Saia entendendo como construir a próxima geração de sistemas de busca inteligentes!</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/DWS38E/</url>
            <location>Intermediate</location>
            
            <attendee>Alex Salgado</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UARFLQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UARFLQ</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T103500</dtstart>
            <dtend>20251025T105500</dtend>
            <duration>0.02000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/UARFLQ/</url>
            <location>Intermediate</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MKKMDW@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MKKMDW</pentabarf:event-slug>
            <pentabarf:title>Conversando com os dados da educação brasileira</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T133000</dtstart>
            <dtend>20251025T141500</dtend>
            <duration>0.04500</duration>
            <summary>Conversando com os dados da educação brasileira</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/MKKMDW/</url>
            <location>Intermediate</location>
            
            <attendee>Belisa Arnhold</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>8BSRRQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-8BSRRQ</pentabarf:event-slug>
            <pentabarf:title>5 lessons you can learn from OpenTelemetry Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T142000</dtstart>
            <dtend>20251025T150500</dtend>
            <duration>0.04500</duration>
            <summary>5 lessons you can learn from OpenTelemetry Python</summary>
            <description>OpenTelemetry Python is a SIG (Special Interest Group) that develops and manages the Python implementation of OpenTelemetry, the second-highest velocity project in the CNCF landscape (only behind Kubernetes). This group delivers a vendor-neutral observability solution, building over 80 Python packages and counting more than 500M downloads per month. This makes it a peculiar project with interesting technical challenges and scales to share the lessons learned.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/8BSRRQ/</url>
            <location>Intermediate</location>
            
            <attendee>Emídio Neto</attendee>
            
            <attendee>Riccardo Magliocchetti</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>AVWT3Z@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-AVWT3Z</pentabarf:event-slug>
            <pentabarf:title>Observability in Python with Pydantic Logfire</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T151000</dtstart>
            <dtend>20251025T155500</dtend>
            <duration>0.04500</duration>
            <summary>Observability in Python with Pydantic Logfire</summary>
            <description>Debugging has evolved far beyond print statements and breakpoints. In this session, we&#x27;ll explore how modern observability practices are revolutionising the way Python developers understand and troubleshoot their applications.

We&#x27;ll trace the evolution of debugging tools and discover how  logs, traces, and metrics, known as the three pillars of observability are essential for identifying and resolving issues.

In this talk, you will learn how spans compose into traces, how structured logs provide context, and how metrics reveal hidden patterns in your application&#x27;s behaviour.
Through a live demo, I&#x27;ll show you how to instrument a FastAPI Python application with Pydantic Logfire, a powerful observability platform built on OpenTelemetry. You will see practical examples of adding observability to your APIs and how it transforms your debugging experience.

The session concludes with an interactive quiz where you can test your knowledge and win prizes!

What You&#x27;ll Learn:
* The evolution from traditional debugging to modern observability
* How logs, traces, spans, and metrics form the foundation of observable systems
* Practical instrumentation techniques with Pydantic Logfire and FastAPI

Join me for a deep dive into Python observability that will change how you debug applications!</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/AVWT3Z/</url>
            <location>Intermediate</location>
            
            <attendee>Laís Carvalho</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7XGPFB@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7XGPFB</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T163000</dtstart>
            <dtend>20251025T170000</dtend>
            <duration>0.03000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/7XGPFB/</url>
            <location>Intermediate</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>KVRFUN@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-KVRFUN</pentabarf:event-slug>
            <pentabarf:title>Explicando Classificações de Imagens com Grad-CAM</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T090000</dtstart>
            <dtend>20251025T094500</dtend>
            <duration>0.04500</duration>
            <summary>Explicando Classificações de Imagens com Grad-CAM</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/KVRFUN/</url>
            <location>Advanced</location>
            
            <attendee>William Moraes da Silva</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NQKYYT@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NQKYYT</pentabarf:event-slug>
            <pentabarf:title>Microserviços com gRPC e FastAPI</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T095000</dtstart>
            <dtend>20251025T103500</dtend>
            <duration>0.04500</duration>
            <summary>Microserviços com gRPC e FastAPI</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/NQKYYT/</url>
            <location>Advanced</location>
            
            <attendee>Lucas de Carvalho Rodrigues da Silva</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UARFLQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UARFLQ</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T103500</dtstart>
            <dtend>20251025T105500</dtend>
            <duration>0.02000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/UARFLQ/</url>
            <location>Advanced</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RTQRZD@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RTQRZD</pentabarf:event-slug>
            <pentabarf:title>Débito arquitetural na prática: quando refatorar não basta</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T133000</dtstart>
            <dtend>20251025T141500</dtend>
            <duration>0.04500</duration>
            <summary>Débito arquitetural na prática: quando refatorar não basta</summary>
            <description>Toda pessoa desenvolvedora já sofreu e sofre com os efeitos nocivos do débito técnico. Porém, há momentos (mais comum que gostaríamos) em que pequenas mudanças não são suficientes para resolver esses problemas e medidas mais drásticas são necessárias: uma grande refatoração envolvendo mudanças na arquitetura do sistema.

Além de uma discussão rápida sobre débitos técnicos com foco na arquitetura, apresentarei um caso de uso real de um sistema legado crítico em um banco digital, passando pelos problemas enfrentados pela empresa e desenvolvedores, apresentando o design do sistema (tentando dar contexto das decisões arquiteturais passadas), as possíveis soluções avaliadas (e seus prós e contras) e, por fim, como foi a implementação da solução final e seus resultados.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/RTQRZD/</url>
            <location>Advanced</location>
            
            <attendee>Luiz Menezes</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>K7WQJZ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-K7WQJZ</pentabarf:event-slug>
            <pentabarf:title>Sistema de self-healing para testes de UI com ML</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T142000</dtstart>
            <dtend>20251025T150500</dtend>
            <duration>0.04500</duration>
            <summary>Sistema de self-healing para testes de UI com ML</summary>
            <description>Seletores quebrados são uma das principais causas de instabilidade em suítes de testes de UI. Mudanças sutis na interface, como a alteração de um atributo ou a reorganização de um componente, podem fazer com que testes falhem, mesmo sem impacto para o usuário final. Isso gera retrabalho, aumenta o custo de manutenção e mina a confiança nos testes automatizados.

Essas falhas comprometem diretamente o fluxo de CI/CD, atrasando entregas, aumentando o tempo de análise de erros e dificultando a identificação do que realmente precisa de atenção. Garantir que a automação seja resiliente é essencial para manter pipelines ágeis e eficientes.

Nesta palestra, apresento um sistema de self-healing para testes de UI com machine learning, desenvolvido para enfrentar esses desafios. A solução identifica falhas causadas por seletores desatualizados e age automaticamente para recuperar os testes e manter o fluxo do CI/CD sem interrupções desnecessárias.

Se você quer tornar sua automação mais inteligente e preparada para aplicações em constante evolução, essa palestra é para você.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/K7WQJZ/</url>
            <location>Advanced</location>
            
            <attendee>Andressa Cabistani</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WRL8NV@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WRL8NV</pentabarf:event-slug>
            <pentabarf:title>Inline cache e Quickening, como o cpython ficou mais rápido</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T151000</dtstart>
            <dtend>20251025T155500</dtend>
            <duration>0.04500</duration>
            <summary>Inline cache e Quickening, como o cpython ficou mais rápido</summary>
            <description>Na versão 3.11 do python tivemos uma reviravolta no assunto desempenho, com melhorias entre 10-60%. Como isso foi possível? Qual a tecnologia envolvida para essas melhorias? Nas versões posteriores, isso foi aprimorado, como foi feito?

Nessa palestra vamos conversar sobre Quickening no cpython e como embutir caches no bytecode mudou tudo.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/WRL8NV/</url>
            <location>Advanced</location>
            
            <attendee>Eduardo Mendes (Dunossauro)</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7XGPFB@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7XGPFB</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251025T163000</dtstart>
            <dtend>20251025T170000</dtend>
            <duration>0.03000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/7XGPFB/</url>
            <location>Advanced</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>DKEQJJ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-DKEQJJ</pentabarf:event-slug>
            <pentabarf:title>Como orçar um projeto de software</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T090000</dtstart>
            <dtend>20251026T094500</dtend>
            <duration>0.04500</duration>
            <summary>Como orçar um projeto de software</summary>
            <description>No último Python Brasil conversei com muitas pessoas que tiveram ideias maravilhosas. O que me chamou a atenção foi que a maioria deles não sabia quanto valia o que estava fazendo, em termos de dinheiro. Isso fez com que projetos e bibliotecas ficassem sem manutenção porque não poderiam ser financiados no futuro.

Meu nome é Jonathan Castro, sou do Equador e tenho uma empresa de software com 12 funcionários. Eu sempre quis que alguém me ensinasse como cobrar ou como financiar meus projetos, sem que as pessoas se aproveitassem de mim no caminho, pedindo descontos enormes.

Mais do que uma aula de economia, esta é uma lição prática sobre como um cliente se comporta na vida real ou como financiar projetos realmente interessantes. Encontre financiadores e compartilhe algumas experiências.


Nesta palestra, você aprenderá um estudo de caso prático sobre como modularizar um projeto, como cobrar por cada módulo e como calcular custos adicionais. Riscos gerais. Como montar uma equipe com um orçamento real. Como oferecer descontos sem comprometer seu projeto.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/DKEQJJ/</url>
            <location>Non-technical</location>
            
            <attendee>Jonathan Castro</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>9TEGWV@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-9TEGWV</pentabarf:event-slug>
            <pentabarf:title>Educação que conecta: da EMEF Zulmira ao Mundo da Tec</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T095000</dtstart>
            <dtend>20251026T103500</dtend>
            <duration>0.04500</duration>
            <summary>Educação que conecta: da EMEF Zulmira ao Mundo da Tec</summary>
            <description>Somos estudantes do 9 ano da escola EMEF Zulmira (ZS) e fazemos parte de um projeto onde aprendemos programação com eletrônica. Durante 1 ano e meio tivemos aulas com educadores que acreditam no nosso potencial e no potencial de compartilhar conhecimentos, inclusive da linguagem python.
Nas aulas aprendemos alguns fundamentos de programação: variável, lógica procedural, condicional, repetição e função. Esses fundamentos foram demonstrados na prática, pois tivemos que construir um semáforo inteligente usando plaquinhas (esp32) e leds, 
a prática com semáforo foi interessante porque é um problema real que usamos no nosso dia a dia. 
Todos os materiais usados esp32 e componentes foram disponibilizados pelos educadores, coisas que em outros projetos normalmente não são disponibilizados. Alguns de nós conhecemos o espaço onde os educadores estudam, elaboram as aulas e aprendem como compartilhar o conhecimento deles com a gente isso é legal, pois percebemos o esforço e dedicação deles.
Além do conhecimento técnico, o ambiente da sala de aula foi importante para a gente conseguir socializar e expressar o que estava na nossa cabeça, como dúvidas, sugestões e curiosidades. Por isso, queremos nesta palestra compartilhar a nossa experiência com o público.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/9TEGWV/</url>
            <location>Non-technical</location>
            
            <attendee>Quenia Gouevia</attendee>
            
            <attendee>Joyce Santos</attendee>
            
            <attendee>Melissa Lima</attendee>
            
            <attendee>Daniel Correa</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UARFLQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UARFLQ</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T103500</dtstart>
            <dtend>20251026T105500</dtend>
            <duration>0.02000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/UARFLQ/</url>
            <location>Non-technical</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>9EYWMP@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-9EYWMP</pentabarf:event-slug>
            <pentabarf:title>Simara Conceição</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T110000</dtstart>
            <dtend>20251026T120000</dtend>
            <duration>1.00000</duration>
            <summary>Simara Conceição</summary>
            <description>Senior Software Developer Google Developer Expert LinkedIn Top Voice Tech &amp; Innovation Apaixonada por inovação, educação e arquitetura de sistemas. Ajudando a reduzir a lacuna de gênero e raça no mercado de tecnologia atuando em projetos educacionais e de conteúdo como Pretalab e Quero Ser Dev.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/9EYWMP/</url>
            <location>Non-technical</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WJNYTQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WJNYTQ</pentabarf:event-slug>
            <pentabarf:title>Cuidado Psicológico em um Mundo de Código</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T133000</dtstart>
            <dtend>20251026T141500</dtend>
            <duration>0.04500</duration>
            <summary>Cuidado Psicológico em um Mundo de Código</summary>
            <description>Burnout, ansiedade, sobrecarga emocional — esses são alguns dos desafios vividos por profissionais da área de tecnologia. Nesta palestra, vamos refletir sobre os impactos psíquicos de uma rotina intensa, muitas vezes marcada por cobranças, longas jornadas e ausência de pausas. A proposta é abrir espaço para pensar a saúde mental de forma profunda, mas acessível, trazendo estratégias de cuidados que podem ser incorporadas ao dia a dia. Tudo isso com uma linguagem clara, acolhedora e livre de tabus — porque cuidar da mente também é uma forma de se manter em desenvolvimento.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/WJNYTQ/</url>
            <location>Non-technical</location>
            
            <attendee>Renalidy Fernanda da Silva</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>E89PTD@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-E89PTD</pentabarf:event-slug>
            <pentabarf:title>Importância dos dados abertos e suas tecnologias resultante</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T142000</dtstart>
            <dtend>20251026T150500</dtend>
            <duration>0.04500</duration>
            <summary>Importância dos dados abertos e suas tecnologias resultante</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/E89PTD/</url>
            <location>Non-technical</location>
            
            <attendee>Carolina Soares</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SLECFU@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SLECFU</pentabarf:event-slug>
            <pentabarf:title>Rafahela Bazzanella</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T154000</dtstart>
            <dtend>20251026T164000</dtend>
            <duration>1.00000</duration>
            <summary>Rafahela Bazzanella</summary>
            <description>Rafahela Bazzanella é mãe do Rodrigo. Membro da comunidade Python desde 2004. Trabalha com Plone há 18 anos. É co-fundadora da comunidade PloneGov-BR e uma das organizadoras da Plone Conference de 2013 e 2024, Python Brasil de 2013 e Python Cerrado de 2024 e 2025. Atualmente trabalha no Programa Interlegis, no Senado Federal, onde desenvolveu e mantém um produto em Plone, chamado Portal Modelo que é utilizado por mais de 1200 Câmaras e Assembléias.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/SLECFU/</url>
            <location>Non-technical</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZQDZWD@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZQDZWD</pentabarf:event-slug>
            <pentabarf:title>Conheça a APyB!</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T170000</dtstart>
            <dtend>20251026T171500</dtend>
            <duration>0.01500</duration>
            <summary>Conheça a APyB!</summary>
            <description>A APyB provê base burocrática e contábil para meetups, eventos e outras inciativas; além de prover guias e bases para organizadores de eventos. A atuação é voluntária, mas tem proporcionado o fortalecimento da disseminação do conhecimento e consolidação do acesso ao conhecimento. 

Valorização dos diferentes saberes, apoio à diversidade e estruturação de apoio junto à Python Software Foundation possibiliatram às diretoras acumular vivências e aprendizados nesta palestra.

Para acompanhar esta palestra, não é necessário nenhum tipo de conhecimento prévio em linguagem de programação: basta apenas ter a vontade de compreender como a comunidade coordena e organiza-se.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>APyB</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/ZQDZWD/</url>
            <location>Non-technical</location>
            
            <attendee>APyB</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RQRESB@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RQRESB</pentabarf:event-slug>
            <pentabarf:title>Entrega do Prêmio Dorneles Treméa/Jean Ferri 2025</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T171500</dtstart>
            <dtend>20251026T173000</dtend>
            <duration>0.01500</duration>
            <summary>Entrega do Prêmio Dorneles Treméa/Jean Ferri 2025</summary>
            <description>Criado em 2011 pela Associação Python Brasil, o Prêmio Dorneles Treméa|Jean Ferri é um momento para a comunidade Python brasileira lembrar e homenagear anualmente a pessoa ou as pessoas que mais se destacaram e contribuíram para manter vivo o espírito de colaboração, empreendedorismo e entrega à comunidade que eram características marcantes de nossos colegas Dorneles Treméa e Jean Ferri.

Critérios utilizados
O prêmio é dedicado àquelas pessoas que, durante os últimos doze meses, se dedicaram a:

Divulgar e ensinar Python
Participar ativamente das comunidades locais
Participar ativamente das comunidades online
Estão excluídos da seleção:

A diretória atual da APyB
Big Kahuna e organizadores da Python Brasil
Homenageados em anos anteriores</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>APyB</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/RQRESB/</url>
            <location>Non-technical</location>
            
            <attendee>APyB</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MHSCJL@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MHSCJL</pentabarf:event-slug>
            <pentabarf:title>Tá bom, Senhor Segurança, mas o que isso significa?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T090000</dtstart>
            <dtend>20251026T094500</dtend>
            <duration>0.04500</duration>
            <summary>Tá bom, Senhor Segurança, mas o que isso significa?</summary>
            <description>Focaremos nas bases da segurança de aplicações, mais especificamente no entendimento do que são CVEs, como entender sua criticidade e sua categorização: O entendimento dessa ferramenta de categorização vai permitir que qualquer desenvolvedor consiga agir de forma proativa para diminuir o risco de falhas de segurança em seu ciclo de desenvolvimento.

Também observaremos ferramentas de notificação mais automáticas como o DependaBot, Pip Audit e o Bandit e entenderemos como elas funcionam e como elas podem se integrar no nosso dia a dia.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/MHSCJL/</url>
            <location>Beginner</location>
            
            <attendee>Nilton Frederico Teixeira</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>EXJMMV@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-EXJMMV</pentabarf:event-slug>
            <pentabarf:title>GraphQL em Python com SGQLC</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T095000</dtstart>
            <dtend>20251026T103500</dtend>
            <duration>0.04500</duration>
            <summary>GraphQL em Python com SGQLC</summary>
            <description>A linguagem GraphQL (Linguagem de Consulta de Grafos) foi criada pelo Facebook para resolver um problema comum em APIs, derivada das extensões &quot;Graph&quot; para REST. Entenda as diferenças para REST, esclareça alguns mitos e preconceitos e entenda como utilizá-la em Python de maneira fácil e eficiente.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/EXJMMV/</url>
            <location>Beginner</location>
            
            <attendee>Gustavo Sverzut Barbieri</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UARFLQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UARFLQ</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T103500</dtstart>
            <dtend>20251026T105500</dtend>
            <duration>0.02000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/UARFLQ/</url>
            <location>Beginner</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SFWYVA@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SFWYVA</pentabarf:event-slug>
            <pentabarf:title>Interagindo com iteradores</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T133000</dtstart>
            <dtend>20251026T141500</dtend>
            <duration>0.04500</duration>
            <summary>Interagindo com iteradores</summary>
            <description>A instrução `for` do Python parece mais limitada que o `for` da linguagem C, mas por baixo do capô Python usa o poderoso padrão de projetos &quot;Iterator&quot;, que fornece uma interface padrão para qualquer código que precise percorrer os itens de uma coleção. Isso acontece não apenas na instrução `for`, mas também em construções como compreensões de lista/dict/set, expressões geradoras, e desempacotamento em tuplas de variáveis.

Nessa palestra veremos como os iteradores funcionam por baixo do capô, qual sua relação com objetos iteráveis, e porque `enumerate` e `zip` são complementos importantes para o laço `for`. Entenderemos em detalhe a lógica do `zip` estudando uma variante escrita em Python, com testes automatizados.

Teremos uma visão panorâmica dos poderosos iteradores prontos para usar incluídos na biblioteca padrõo de Python, e finalmente veremos quando não usar iteradores.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/SFWYVA/</url>
            <location>Beginner</location>
            
            <attendee>Luciano Ramalho</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>CWEQHK@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CWEQHK</pentabarf:event-slug>
            <pentabarf:title>Tarefas chatas - quando automatizar e como a IA me ajudou?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T142000</dtstart>
            <dtend>20251026T150500</dtend>
            <duration>0.04500</duration>
            <summary>Tarefas chatas - quando automatizar e como a IA me ajudou?</summary>
            <description>Quando dizemos que um bom programador é preguiçoso, queremos dizer, entre outras coisas, que bons programadores automatizam tarefas repetitivas. Criamos testes unitários para não precisarmos testar várias vezes a mesma coisa, criamos pipelines de deploy automatizados para não precisarmos executar o mesmo deploy várias vezes, automatizamos a formatação e a análise estática do nosso código, entre outros. Nessa palestra vou falar sobre quando vale a pena automatizar uma tarefa repetitiva. Geralmente tem relação com retorno sobre investimento: o tempo que você vai economizar ao automatizar essa tarefa compensa o tempo que você vai investir nisso? Com a IA e os LLMs, esse investimento diminuiu bastante e eu vou mostrar alguns exemplos de uso da IA que me ajudaram nisso.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/CWEQHK/</url>
            <location>Beginner</location>
            
            <attendee>Vinicius Mendes</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NRP8TG@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NRP8TG</pentabarf:event-slug>
            <pentabarf:title>Mercados: acessando dados do mercado financeiro com Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T090000</dtstart>
            <dtend>20251026T094500</dtend>
            <duration>0.04500</duration>
            <summary>Mercados: acessando dados do mercado financeiro com Python</summary>
            <description>Muitos sistemas que acessam dados do mercado financeiro são fechados - e a cultura de dados abertos é quase que inexistente nessa indústria, dada a concorrência entre as empresas. Apesar disso, o mercado financeiro exerce bastante poder econômico sobre a sociedade e existem órgãos, como a Comissão de Valores Mobiliários, que fiscalizam os atores do mercado.
Dados abertos (e gratuitos existem), porém, muita informação está fragmentada em sistemas da CVM, na B3 (que é um monopólio no Brasil), no Banco Central e em diversos outros órgãos/sites.

Nesta palestra será apresentada a biblioteca Python `mercados`, criada para facilitar o acesso a esses dados e fomentar a transparência no setor. Com ela, é possível acessar de forma unificada e padronizada informações como:
- Dados históricos de Fundos de Investimento (FundosNET / CVM)
- Ofertas públicas e documentos regulatórios da CVM
- Taxas de juros e indicadores econômicos do Banco Central
- Arquivos da B3 com históricos de FII, FIP, Fi-Agro, debêntures etc.
- Documentos oficiais de empresas listadas na bolsa
- Dentre muitos outros

O objetivo é empoderar desenvolvedores, jornalistas e qualquer cidadão a explorar, cruzar e fiscalizar dados financeiros com poucas linhas de código, promovendo controle social e educação financeira baseada em dados públicos.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/NRP8TG/</url>
            <location>Intermediate</location>
            
            <attendee>Álvaro Justen</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>YBYFSN@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-YBYFSN</pentabarf:event-slug>
            <pentabarf:title>Otimizando Pipelines com Tracing de Alta Performance</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T095000</dtstart>
            <dtend>20251026T103500</dtend>
            <duration>0.04500</duration>
            <summary>Otimizando Pipelines com Tracing de Alta Performance</summary>
            <description>Imagine reduzir o tempo de execução da sua pipeline Python sem adivinhar onde estão os gargalos. O Perfetto — ferramenta open-source criada pelo Google — oferece isso: um sistema de tracing unificado que revela desde as funções mais básicas do seu programa até locks disputados em threads até chamadas de I/O custosas, tudo com visualização intuitiva direto no browser e baixo overhead.

**Neste palestra, você vai:**
Aprender sobre o uso do tracing em pipelines;
Instrumentar seu código Python para gerar traces;
Analisar dados no Perfetto UI como um engenheiro do Android faz: identificando padrões de CPU, memória e latência;
Observar como foi feita a otimização de um caso real passo a passo, desde a coleta até a implementação das melhorias (com métricas &quot;antes vs depois&quot;).

**Para quem é esse palestra?**
Quem já bateu nos limites de otimização com ferramentas convencionais.
Devs curiosos sobre como seus programas usam os recursos da sua máquina.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/YBYFSN/</url>
            <location>Intermediate</location>
            
            <attendee>Isabelle</attendee>
            
            <attendee>André Braga</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UARFLQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UARFLQ</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T103500</dtstart>
            <dtend>20251026T105500</dtend>
            <duration>0.02000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/UARFLQ/</url>
            <location>Intermediate</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>9D7VUG@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-9D7VUG</pentabarf:event-slug>
            <pentabarf:title>Parse Don’t Validate: menos if&#x27;s, mais confiança</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T133000</dtstart>
            <dtend>20251026T141500</dtend>
            <duration>0.04500</duration>
            <summary>Parse Don’t Validate: menos if&#x27;s, mais confiança</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/9D7VUG/</url>
            <location>Intermediate</location>
            
            <attendee>Jhonata Medeiros</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>8JUBYN@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-8JUBYN</pentabarf:event-slug>
            <pentabarf:title>Descobrindo PySpark - Dicas de Essenciais de Otimização</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T142000</dtstart>
            <dtend>20251026T150500</dtend>
            <duration>0.04500</duration>
            <summary>Descobrindo PySpark - Dicas de Essenciais de Otimização</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/8JUBYN/</url>
            <location>Intermediate</location>
            
            <attendee>Priscila Santana</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>AULFVV@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-AULFVV</pentabarf:event-slug>
            <pentabarf:title>Python com motor de foguete: Rust na engenharia de dados</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T090000</dtstart>
            <dtend>20251026T094500</dtend>
            <duration>0.04500</duration>
            <summary>Python com motor de foguete: Rust na engenharia de dados</summary>
            <description>Python sempre foi uma escolha popular para engenharia de dados, mas com grandes limitações de performance. Nos últimos anos, bibliotecas com núcleo em Rust têm revolucionado esse cenário. Ferramentas como Polars, DuckDB, DataFusion e PyO3 trazem velocidade e eficiência sem abandonar a familiaridade e flexibilidade do Python.

Nesta talk, vamos entender:

- O papel do Rust na nova geração de ferramentas de dados

- Como essas bibliotecas funcionam “por trás dos panos”

- Quais ganhos práticos de performance e produtividade elas trazem

- Como isso muda o desenvolvimento de pipelines, exploração de dados e construção de ferramentas analíticas

A proposta é oferecer uma visão técnica e estratégica para quem trabalha com dados e quer entender o futuro do Python nesse contexto.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/AULFVV/</url>
            <location>Advanced</location>
            
            <attendee>Carlos Magalhães</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XBCZHZ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XBCZHZ</pentabarf:event-slug>
            <pentabarf:title>Python: Poderia Ser A Linguagem Mais Rápida de Todas?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T095000</dtstart>
            <dtend>20251026T103500</dtend>
            <duration>0.04500</duration>
            <summary>Python: Poderia Ser A Linguagem Mais Rápida de Todas?</summary>
            <description>Com  a ascensão ao pódio do índice Tiobe, de mais projetos no GitHub, no Stackoverflow, e quase qualquer outro índice de popularidade de linguagens, o &quot;rebote&quot; veio forte: em algumas mídias, de repente se tornou &quot;feio&quot; programar em Python. &quot;linguagem de scripts pra iniciantes&quot;, &quot;linguagem desestruturada&quot; &quot;eu não usaria&quot;, &quot;LENTA&quot;, &quot;Interpretada&quot;. Será que é isso?

Fatores psicológicos de &quot;se é do povão, sou contra&quot; à parte, vamos descer as raízes do sucesso da linguagem: sua ergonomia, e subir de volta ao seu ponto &quot;popularmente&quot; mais fraco: a velocidade.

Nos últimos meses circulou um gif animado &quot;demonstrando&quot; a &quot;performance&quot; das linguagens, em que Python aparecia em último em um certo benchmark, milhares de vezes mais lenta que as linguagens &quot;chiques&quot; ou de &quot;desenvolvedores sérios&quot;.

A proposta é (1) perceber que aquilo é um meme, (2) Python NÃO PRECISA ser mais rápido do que a ordem de grandeza atual e (3) Python PODE ser ordens de grandeza mais rápido do que é. E como tudo isso está relacionado com seus pontos mais fortes. 

Mais tecnicamente: vamos entender 
  - porque a sintaxe e expressividade que todos amamos não precisa ter um único caminho para se tornar o código que é executado, e quais vias para &quot;velocidade bruta&quot; estão abertas,
  - e qual o papel de Python como linguagem orquestradora de código de alta performance.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/XBCZHZ/</url>
            <location>Advanced</location>
            
            <attendee>João Sebastião de Oliveira Bueno</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UARFLQ@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UARFLQ</pentabarf:event-slug>
            <pentabarf:title>Palestras relâmpago</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T103500</dtstart>
            <dtend>20251026T105500</dtend>
            <duration>0.02000</duration>
            <summary>Palestras relâmpago</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Palestras relâmpago</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/UARFLQ/</url>
            <location>Advanced</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>X9WQSR@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-X9WQSR</pentabarf:event-slug>
            <pentabarf:title>Python com TSDB: aprendizados em manutenção preditiva</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T133000</dtstart>
            <dtend>20251026T141500</dtend>
            <duration>0.04500</duration>
            <summary>Python com TSDB: aprendizados em manutenção preditiva</summary>
            <description>A manutenção preditiva evita falhas, reduz custos e aumenta eficiência operacional através do monitoramento contínuo de dados, geração de alarmes inteligentes e planejamento da rotina de reparos. Nesta palestra, você verá como construímos uma engine que empodera engenheiros e técnicos a criarem seus próprios cálculos para gerar alarmes precisos, combinando seus conhecimentos com modelos de machine learning para uma atuação ainda mais segura. 

Usando Python, TDSB e arquitetura assíncrona, nossa solução transforma dados em decisões ágeis, unindo expertise humana e inteligência artificial para antecipar problemas e otimizar recursos na Indústria 4.0.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/X9WQSR/</url>
            <location>Advanced</location>
            
            <attendee>Luciana Midori Murata</attendee>
            
            <attendee>Nilane Arruda</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>YPZXLK@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-YPZXLK</pentabarf:event-slug>
            <pentabarf:title>Como salvar uma função definida em um notebook?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251026T142000</dtstart>
            <dtend>20251026T150500</dtend>
            <duration>0.04500</duration>
            <summary>Como salvar uma função definida em um notebook?</summary>
            <description>Na Shape Digital, embora tenhamos milhares modelos de machine learning em produção, muitos deles requerem um pré-processamento de dados customizado. Para reduzir o atrito de exigir que o código que implementa cada um desses pré-processamentos seja mantido em um repositório, o que fazemos é embutir “a função em si” no modelo que será enviado para produção.

Mas o que é “a função em si”? Nessa palestra, apresentaremos o ciclo de vida de uma função no CPython. Para quem não sabe, “Python” é o nome da linguagem de programação, mas o interpretador que lê o código que a gente escreveu em Python e o executa se chama “CPython” (porque é escrito em C).

Vamos explorar como funciona a definição de uma função via código-fonte, como elas são compiladas para bytecode, como são representadas internamente pelo interpretador, como funciona exatamente o processo de execução do bytecode, e como podemos inspecionar o interpretador “ao vivo” (em tempo de execução) para ter acesso a todos esses “internals.”

Por fim, vamos mostrar como interagimos com todas essas etapas para executar em produção, de forma segura e portável, a função que foi definida pelo cientista de dados em um notebook Databricks.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/YPZXLK/</url>
            <location>Advanced</location>
            
            <attendee>Pedro Fonini</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PRN98H@@talks.python.org.br</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PRN98H</pentabarf:event-slug>
            <pentabarf:title>Pituguês</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>pt-br</pentabarf:language>
            <pentabarf:language-code>pt-br</pentabarf:language-code>
            <dtstart>20251027T090000</dtstart>
            <dtend>20251027T180000</dtend>
            <duration>9.00000</duration>
            <summary>Pituguês</summary>
            <description>Venha participar da sprint do Pituguês! Esta é uma oportunidade para todas as pessoas que desejam contribuir com o desenvolvimento de uma linguagem de programação em português, acessível e pensada para quem está começando na programação ou quer fortalecer a cultura de código aberto. Durante a sprint, vamos colaborar em diversas frentes: implementação de novos recursos, revisão de código, melhoria da documentação e criação de exemplos de programas. Não é necessário ter experiência prévia em contribuição com projetos open source: haverá espaço para quem quer programar, traduzir, escrever documentação ou ajudar no design. Juntas, vamos fortalecer o ecossistema de linguagens em português e ampliar o acesso à tecnologia.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Sprint</category>
            <url>https://talks.python.org.br/pythonbrasil-2025/talk/PRN98H/</url>
            <location>FIAP - Sprints</location>
            
            <attendee>Maria Antônia Maia</attendee>
            
        </vevent>
        
    </vcalendar>
</iCalendar>
