Welcome to EuroPython 2025! Please notice the registration will happen on the Forum Hall Foyer on the 1st Floor.
You can pick up your badges at any time during the week as long as we are open!
If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!
The C API Summit aims to bring together various stakeholders of Python’s C API to discuss its current state, address challenges, and align on ongoing work.
- When: Monday, July 14th or Tuesday, July 15th (to be confirmed)
- Where: Prague Congress Centre (PCC), Room to be announced
- Who can join: Anyone with a valid in-person EuroPython 2025 ticket
Meet the Community
The main goal of this summit is for various stakeholders of Python’s C API to meet and discuss about the state of the API, existing challenges and ongoing work.
We are particularly looking for contributors and maintainers of:
- Python implementations with a C API (e.g., CPython, PyPy, GraalPy, MicroPython)
- Binding generators and alternative APIs (e.g., HPy, Cython, pybind11, PyO3, SWIG)
- Libraries that use the C API heavily or in innovative ways
- Applications that embed Python
- Similar projects working in this area
How to make your Python project robust ?
Python has a reputation for being a language that does not value software quality. However, over the past 20 years, Python has become a widely used language in the tech industry, with notable successes like Instagram, Spotify, Reddit, Dropbox, ….
To achieve high-quality software through Python programming, it is essential to understand the language's structure and its ecosystem, as well as the tools and practices to adopt.
In this tutorial, we will explore the structure of a Python project, the language's fundamental principles, the many tools to use, and the techniques to be applied in order to work with Python at an industrial level.
We'll cover the whole Python project lifecycle (start, add dependencies, run, build, publish), guided by quality and automation tools (uv, ruff, pytest, Mypy, IDE, pre-commit, doit, Docker, CI), with a focus on standards and speed. You'll leave with a good understanding of this workflow, and a reference Python project that you'll be able to get examples from for your personnal or professional projects.
Pre-requisites for this tutorial:
* The ability to write Python code
* Access to install software on your machine (network connection and administrator rights)
* A shell (Powershell or Bash or ...)
Using Strawberry with Django, you can build an efficient, async GraphQL backend. Strawberry’s use of Python’s async capabilities enables high performance, while its integration with Django provides a robust foundation.
Key features include:
DataLoaders: Batch and cache database queries to reduce load and improve performance
Object Types: Define your data’s structure clearly and flexibly
Queries: Retrieve data efficiently with customizable GraphQL query structures
Mutations: Implement data modification operations cleanly and predictably
In this workshop, we will cover the very basic of using PyO3 - rust library that package rust crates into Python modules. This is the most popular tool in terms of creating Python libraries with Rust.
In recent years, Rust has been getting more and more popular over other similar programming languages like C and C++ due to its robust compiler checking and ownership rules to make sure memory is safe. Hence there are more and more Python libraries that have been written in Rust natively with a Python API interface. One of the tools that have been driving this movement is PyO3, a toolset that proves Rust bindings for Python and tools for creating native Python extension modules.
In this interactive workshop, we will cover the very basics of using PyO3. There will be hands-on exercises to go from how to set up the project environment to writing a "toy" Python library written in Rust using PyO3. We will cover a lot of expectations of the API provided by PyO3 to create Python functions, modules, handling errors and converting types.
Goal
To give developers who are not familiar with PyO3 an introduction to PyO3 so they can consider building their Python libraries with Rust to make use of Rust's memory-safe property and parallelism ability.
Target audiences
Any developers who are interested in developing Python libraries using Rust. It will be an advantage if the attendees are comfortable writing in Rust. However, attendees are not required to be familiar with Rust as all the Rust codes will be provided. Basic knowledge of Python will be assumed from the attendees.
Outline
Part 1 - introduction and getting started (40 mins)
- What's the difference between Rust and Python (5 mins)
- Why using PyO3 (5 mins)
- Setting up the environment (exercises) (15 mins)
- Starting a new project (exercises) (15 mins)
Break (15 mins)
Part 2 - Creating a simple Python library (100 mins)
- Creating Python modules (exercises) (40 mins)
- Generating documentation
- Creating Python functions (exercises) (60 mins)
- How to create function signatures
- How to deal wi
The pytest tool offers a rapid and simple way to write tests for your Python code. This training gives an introduction with exercises to some distinguishing features, such as its assertions, marks and fixtures.
Despite its simplicity, pytest is incredibly flexible and configurable. We'll look at various configuration options as well as the plugin ecosystem around pytest.
Most of the applications are being powered by Generative AI. Some of the key proponents of Generative AI stem from concepts like RAG, Vector search and embeddings. This tutorial covers these core concepts on Vector search and is complete guide to help guide you from 0 to 1 in Vector Search with open source tools, libraries in Python understanding not only the core meaning of these terms but also hands on projects.
A special focus of this tutorial is to also learn how to build privacy focused applications. A lot of times user send data to LLM cloud providers like OpenAI, raising privacy concerns. This tutorial will also emphasise on an alternative and privacy focused way to build AI applications by running LLMs locally with Ollama that keep everything local on your computer. This approach allows to avoid sending sensitive information to external servers. The tutorial also highlights LangChain's ability to create versatile AI agents capable of handling tasks autonomously by creating embeddings for the data. So come learn how can you build the next gen, privacy focused Vector search application powered by Local LLMs, open source vector databases while learning the key concepts of Generative AI such as Vector search, embeddings and practical use cases with an end to end example.
The C API Summit aims to bring together various stakeholders of Python’s C API to discuss its current state, address challenges, and align on ongoing work.
- When: Monday, July 14th or Tuesday, July 15th (to be confirmed)
- Where: Prague Congress Centre (PCC), Room to be announced
- Who can join: Anyone with a valid in-person EuroPython 2025 ticket
Meet the Community
The main goal of this summit is for various stakeholders of Python’s C API to meet and discuss about the state of the API, existing challenges and ongoing work.
We are particularly looking for contributors and maintainers of:
- Python implementations with a C API (e.g., CPython, PyPy, GraalPy, MicroPython)
- Binding generators and alternative APIs (e.g., HPy, Cython, pybind11, PyO3, SWIG)
- Libraries that use the C API heavily or in innovative ways
- Applications that embed Python
- Similar projects working in this area
How to make your Python project robust ?
Python has a reputation for being a language that does not value software quality. However, over the past 20 years, Python has become a widely used language in the tech industry, with notable successes like Instagram, Spotify, Reddit, Dropbox, ….
To achieve high-quality software through Python programming, it is essential to understand the language's structure and its ecosystem, as well as the tools and practices to adopt.
In this tutorial, we will explore the structure of a Python project, the language's fundamental principles, the many tools to use, and the techniques to be applied in order to work with Python at an industrial level.
We'll cover the whole Python project lifecycle (start, add dependencies, run, build, publish), guided by quality and automation tools (uv, ruff, pytest, Mypy, IDE, pre-commit, doit, Docker, CI), with a focus on standards and speed. You'll leave with a good understanding of this workflow, and a reference Python project that you'll be able to get examples from for your personnal or professional projects.
Pre-requisites for this tutorial:
* The ability to write Python code
* Access to install software on your machine (network connection and administrator rights)
* A shell (Powershell or Bash or ...)
Using Strawberry with Django, you can build an efficient, async GraphQL backend. Strawberry’s use of Python’s async capabilities enables high performance, while its integration with Django provides a robust foundation.
Key features include:
DataLoaders: Batch and cache database queries to reduce load and improve performance
Object Types: Define your data’s structure clearly and flexibly
Queries: Retrieve data efficiently with customizable GraphQL query structures
Mutations: Implement data modification operations cleanly and predictably
In this workshop, we will cover the very basic of using PyO3 - rust library that package rust crates into Python modules. This is the most popular tool in terms of creating Python libraries with Rust.
In recent years, Rust has been getting more and more popular over other similar programming languages like C and C++ due to its robust compiler checking and ownership rules to make sure memory is safe. Hence there are more and more Python libraries that have been written in Rust natively with a Python API interface. One of the tools that have been driving this movement is PyO3, a toolset that proves Rust bindings for Python and tools for creating native Python extension modules.
In this interactive workshop, we will cover the very basics of using PyO3. There will be hands-on exercises to go from how to set up the project environment to writing a "toy" Python library written in Rust using PyO3. We will cover a lot of expectations of the API provided by PyO3 to create Python functions, modules, handling errors and converting types.
Goal
To give developers who are not familiar with PyO3 an introduction to PyO3 so they can consider building their Python libraries with Rust to make use of Rust's memory-safe property and parallelism ability.
Target audiences
Any developers who are interested in developing Python libraries using Rust. It will be an advantage if the attendees are comfortable writing in Rust. However, attendees are not required to be familiar with Rust as all the Rust codes will be provided. Basic knowledge of Python will be assumed from the attendees.
Outline
Part 1 - introduction and getting started (40 mins)
- What's the difference between Rust and Python (5 mins)
- Why using PyO3 (5 mins)
- Setting up the environment (exercises) (15 mins)
- Starting a new project (exercises) (15 mins)
Break (15 mins)
Part 2 - Creating a simple Python library (100 mins)
- Creating Python modules (exercises) (40 mins)
- Generating documentation
- Creating Python functions (exercises) (60 mins)
- How to create function signatures
- How to deal wi
The pytest tool offers a rapid and simple way to write tests for your Python code. This training gives an introduction with exercises to some distinguishing features, such as its assertions, marks and fixtures.
Despite its simplicity, pytest is incredibly flexible and configurable. We'll look at various configuration options as well as the plugin ecosystem around pytest.
Most of the applications are being powered by Generative AI. Some of the key proponents of Generative AI stem from concepts like RAG, Vector search and embeddings. This tutorial covers these core concepts on Vector search and is complete guide to help guide you from 0 to 1 in Vector Search with open source tools, libraries in Python understanding not only the core meaning of these terms but also hands on projects.
A special focus of this tutorial is to also learn how to build privacy focused applications. A lot of times user send data to LLM cloud providers like OpenAI, raising privacy concerns. This tutorial will also emphasise on an alternative and privacy focused way to build AI applications by running LLMs locally with Ollama that keep everything local on your computer. This approach allows to avoid sending sensitive information to external servers. The tutorial also highlights LangChain's ability to create versatile AI agents capable of handling tasks autonomously by creating embeddings for the data. So come learn how can you build the next gen, privacy focused Vector search application powered by Local LLMs, open source vector databases while learning the key concepts of Generative AI such as Vector search, embeddings and practical use cases with an end to end example.
All code needs a user interface. That might be an API, or a web page - but these days, many users will expect an app that they can install on their laptop, or on their phone. But how do you build a native application in Python? And do you need to build a different version of your app the app for every device and operating system you want to support?
In this hands-on tutorial, you'll lean how you can use the BeeWare suite of tools to build a graphical user interface for your code, and deploy that code as a desktop app, and as a mobile app - all from a single Python codebase. You'll learn how to integrate third-party libraries like NumPy into your app, and how to customize the appearance of your packaged app. You'll also learn how you can access device hardware (such as cameras an accelerometers) in your app's code.
No experience with mobile or desktop app development is required; a basic familiarity with Python is all you need. By the end of the tutorial, you'll have an app running on your own phone, written entirely by you, using nothing but Python.
The C API Summit aims to bring together various stakeholders of Python’s C API to discuss its current state, address challenges, and align on ongoing work.
- When: Monday, July 14th or Tuesday, July 15th (to be confirmed)
- Where: Prague Congress Centre (PCC), Room to be announced
- Who can join: Anyone with a valid in-person EuroPython 2025 ticket
Meet the Community
The main goal of this summit is for various stakeholders of Python’s C API to meet and discuss about the state of the API, existing challenges and ongoing work.
We are particularly looking for contributors and maintainers of:
- Python implementations with a C API (e.g., CPython, PyPy, GraalPy, MicroPython)
- Binding generators and alternative APIs (e.g., HPy, Cython, pybind11, PyO3, SWIG)
- Libraries that use the C API heavily or in innovative ways
- Applications that embed Python
- Similar projects working in this area
Because of the Global Interpreter Lock (GIL), Python has never truly been parallel. Even on multi-core systems, Python threads are forced to take turns rather than running simultaneously, limiting performance in compute-heavy applications. The recent removal of the GIL is unlocking new levels of concurrency and efficiency, redefining what’s possible with Python in high-performance computing.
In this hands-on tutorial, we will demystify parallel programming in Python by showcasing how to tackle common concurrency challenges. Starting from the ground up, we will introduce the two common parallel-programming approaches in Python—multithreading and multiprocessing—ensuring that attendees of all experience levels can successfully participate in the tutorial.
From there, we will dive into real-life use cases and demonstrate how to leverage free-threaded Python to tap into the power of GPUs. By pairing Python’s parallel libraries with CUDA, you will learn how to accelerate both typical computing tasks and more advanced work, such as deep learning. We will also explore the best tools available for debugging, monitoring, and optimizing multi-threaded and GPU-accelerated applications, all while highlighting proven best practices.
Throughout the tutorial, you will have the chance to work through exercises—from simple parallel calls to complex GPU integrations—so make sure to bring your laptop. Ideally, your laptop should have a GPU; if not, we will show you how to use one available online.
By the end, you will walk away with not only a solid understanding of GIL-free Python but also the confidence to implement, debug, and optimize parallel solutions in your own projects.
GeoData isn’t just about shapefiles and small satellite images anymore. With the explosion of open data portals, satellite constellations, and IoT devices, geospatial datasets can easily reach terabytes in size. This advanced, hands-on workshop will teach you how to efficiently load, process, and analyze large-scale geospatial data in Python. We’ll cover distributed frameworks like Dask for parallelizing vector and raster processing, advanced data structures for high-performance spatial operations, and best practices for memory and I/O optimization. Whether you’re dealing with national-scale road networks or multi-temporal satellite imagery, you’ll come away with concrete strategies and code examples to tackle big GeoData on modern hardware and in the cloud.
PyScript is a fast growing and vibrant open source platform for Python in the browser. Thanks to PyScript, CPython and MicroPython run anywhere a browser runs, which is everywhere!
This tutorial, aimed at all levels of experience and delivered by PyScript core developers, will take you through initial steps needed to get PyScript working (hint: it's a single line added to an HTML <head> element). Afterwards we'll explore the many APIs, modules, libraries, frameworks and tooling that have coalesced around PyScript since its announcement three years ago. This will involve a guided tour of the potpourri of PyScript: tooling, idiomatic PyScript, core browser capabilities, writing games, data science, artificial intelligence, application frameworks and UI toolkits, and Internet of Things / robotics. We'll finish with an extended opportunity for folks to get their hands dirty with PyScript based explorations and conclude with a friendly and supportive "show and tell" session where folks can demo their work and share their experiences.
By the end of the tutorial you'll be a confident user of PyScript, understand its expanding ecosystem and know where the community signposts and gatherings can be found. But most of all, it's going to be a lot of stimulating supportive fun.
This tutorial complements and would be excellent prep for Łukasz Langa's advanced, and frankly mind-blowing, PyScript / WebGL tutorial in the afternoon.
Transform your presentations with Python! In this hands-on tutorial, attendees will learn tools, tricks, and libraries to create impactful presentations for public speaking or teaching. Starting with a bad presentation, we'll learn and apply storytelling, create attractive visual artifacts and use technical tools to turn it into a memorable presentation.
All code needs a user interface. That might be an API, or a web page - but these days, many users will expect an app that they can install on their laptop, or on their phone. But how do you build a native application in Python? And do you need to build a different version of your app the app for every device and operating system you want to support?
In this hands-on tutorial, you'll lean how you can use the BeeWare suite of tools to build a graphical user interface for your code, and deploy that code as a desktop app, and as a mobile app - all from a single Python codebase. You'll learn how to integrate third-party libraries like NumPy into your app, and how to customize the appearance of your packaged app. You'll also learn how you can access device hardware (such as cameras an accelerometers) in your app's code.
No experience with mobile or desktop app development is required; a basic familiarity with Python is all you need. By the end of the tutorial, you'll have an app running on your own phone, written entirely by you, using nothing but Python.
The C API Summit aims to bring together various stakeholders of Python’s C API to discuss its current state, address challenges, and align on ongoing work.
- When: Monday, July 14th or Tuesday, July 15th (to be confirmed)
- Where: Prague Congress Centre (PCC), Room to be announced
- Who can join: Anyone with a valid in-person EuroPython 2025 ticket
Meet the Community
The main goal of this summit is for various stakeholders of Python’s C API to meet and discuss about the state of the API, existing challenges and ongoing work.
We are particularly looking for contributors and maintainers of:
- Python implementations with a C API (e.g., CPython, PyPy, GraalPy, MicroPython)
- Binding generators and alternative APIs (e.g., HPy, Cython, pybind11, PyO3, SWIG)
- Libraries that use the C API heavily or in innovative ways
- Applications that embed Python
- Similar projects working in this area
Because of the Global Interpreter Lock (GIL), Python has never truly been parallel. Even on multi-core systems, Python threads are forced to take turns rather than running simultaneously, limiting performance in compute-heavy applications. The recent removal of the GIL is unlocking new levels of concurrency and efficiency, redefining what’s possible with Python in high-performance computing.
In this hands-on tutorial, we will demystify parallel programming in Python by showcasing how to tackle common concurrency challenges. Starting from the ground up, we will introduce the two common parallel-programming approaches in Python—multithreading and multiprocessing—ensuring that attendees of all experience levels can successfully participate in the tutorial.
From there, we will dive into real-life use cases and demonstrate how to leverage free-threaded Python to tap into the power of GPUs. By pairing Python’s parallel libraries with CUDA, you will learn how to accelerate both typical computing tasks and more advanced work, such as deep learning. We will also explore the best tools available for debugging, monitoring, and optimizing multi-threaded and GPU-accelerated applications, all while highlighting proven best practices.
Throughout the tutorial, you will have the chance to work through exercises—from simple parallel calls to complex GPU integrations—so make sure to bring your laptop. Ideally, your laptop should have a GPU; if not, we will show you how to use one available online.
By the end, you will walk away with not only a solid understanding of GIL-free Python but also the confidence to implement, debug, and optimize parallel solutions in your own projects.
GeoData isn’t just about shapefiles and small satellite images anymore. With the explosion of open data portals, satellite constellations, and IoT devices, geospatial datasets can easily reach terabytes in size. This advanced, hands-on workshop will teach you how to efficiently load, process, and analyze large-scale geospatial data in Python. We’ll cover distributed frameworks like Dask for parallelizing vector and raster processing, advanced data structures for high-performance spatial operations, and best practices for memory and I/O optimization. Whether you’re dealing with national-scale road networks or multi-temporal satellite imagery, you’ll come away with concrete strategies and code examples to tackle big GeoData on modern hardware and in the cloud.
PyScript is a fast growing and vibrant open source platform for Python in the browser. Thanks to PyScript, CPython and MicroPython run anywhere a browser runs, which is everywhere!
This tutorial, aimed at all levels of experience and delivered by PyScript core developers, will take you through initial steps needed to get PyScript working (hint: it's a single line added to an HTML <head> element). Afterwards we'll explore the many APIs, modules, libraries, frameworks and tooling that have coalesced around PyScript since its announcement three years ago. This will involve a guided tour of the potpourri of PyScript: tooling, idiomatic PyScript, core browser capabilities, writing games, data science, artificial intelligence, application frameworks and UI toolkits, and Internet of Things / robotics. We'll finish with an extended opportunity for folks to get their hands dirty with PyScript based explorations and conclude with a friendly and supportive "show and tell" session where folks can demo their work and share their experiences.
By the end of the tutorial you'll be a confident user of PyScript, understand its expanding ecosystem and know where the community signposts and gatherings can be found. But most of all, it's going to be a lot of stimulating supportive fun.
This tutorial complements and would be excellent prep for Łukasz Langa's advanced, and frankly mind-blowing, PyScript / WebGL tutorial in the afternoon.
Transform your presentations with Python! In this hands-on tutorial, attendees will learn tools, tricks, and libraries to create impactful presentations for public speaking or teaching. Starting with a bad presentation, we'll learn and apply storytelling, create attractive visual artifacts and use technical tools to turn it into a memorable presentation.
Welcome to EuroPython 2025! Please notice the registration will happen on the Forum Hall Foyer on the 1st Floor.
You can pick up your badges at any time during the week as long as we are open!
If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!
Managing a database and synchronizing service data representation with the database can be tricky. In this workshop, you’ll learn how to use SQLAlchemy, a powerful SQL toolkit, to simplify this task. We’ll cover how to leverage SQLAlchemy’s Object Relational Mapper (ORM) system, and how to use ORM’s asyncio extension in your async services.
Participants will walk out of this tutorial having learned how to:
- Use SQLAlchemy for database operations in Python, enhancing the readability and maintainability of the code
- Build Python classes (ORMs) that represent the database tables
- Experiment with different relationship-loading techniques to improve querying performance
- Utilize SQLAlchemy’s asyncio extension to interact with databases asynchronously
The industry is abuzz with the term "Vertical Agents," yet there’s often little clarity on how Agents work. At its core, however, an Agent is simply a workflow designed to automate tasks by using environment tools and enhancing its ability to reason, plan, decompose, and execute a given task.
In this talk, we’ll explore the necessity of planning and reasoning in various industries and build a practical use case in the Education domain. The application will answer user questions based on provided academic notes, and if the information isn’t available, it will seamlessly search the web. The decision-making process—whether to use existing knowledge or external sources—is where an Agent's role shines. To define and manage a custom knowledge base, we’ll utilize a Retrieval-Augmented Generation (RAG) approach.
With Agentic RAG, the audience will gain clarity on routing concepts, learn how to design an efficient architecture and understand how the Thought-Action-Observation loop enables an Agent to function effectively. As for the technical aspect, we will use LlamaIndex for the routing with its ReAcT Agent and Qdrant as the vector database with Hybrid Search capabilities.
The Rust Summit aims to bring together various stakeholders of Python’s Rust ecosystem to discuss its current state, address challenges, and align on ongoing work.
- When: Monday, July 14th or Tuesday, July 15th (to be confirmed)
- Where: Prague Congress Centre (PCC), Room to be announced
- Who can join: Anyone with a valid in-person EuroPython 2025 ticket
CI/CD (Continuous Integration and Continuous Deployment) has become a fundamental part of DevOps, helping teams deliver code quickly and catch potential problems before they turn into costly production issues. Without a solid CI/CD process, developers often struggle with manual deployments, inconsistent environments, and unexpected bugs that slip through the cracks, causing frustration and unplanned downtime.
In this session, we will walk you step by step through setting up a dependable CI/CD pipeline using Python, Jenkins, TestContainers AWS, and Kubernetes. Starting with basic configurations, we’ll automate everything from running tests to building containers and deploying them on a scalable Kubernetes cluster. By writing simple Python scripts, you will learn how to streamline repetitive tasks and create a smooth release workflow. We’ll also take time to discuss common pitfalls and show how to troubleshoot them, so you feel equipped to handle real-world challenges.
Whether you’re new to CI/CD or looking to refine your existing DevOps skills, this tutorial aims to make complex workflows easier to grasp. Expect hands-on practice, clear explanations, and practical takeaways that you can apply in your own projects right away. By the end, you’ll see how using Python at each stage not only automates time-consuming tasks but also brings a new level of reliability to the entire deployment process.
Our goal is to help you build confidence in creating a pipeline that brings predictability to your releases, saves your team time, and keeps your applications running smoothly in production. If you’ve ever wanted to see how a proper CI/CD setup can transform the way you ship software, this is your chance to dive in and see it come to life step by step.
Whenever you use a dot in Python you access an attribute.
While this seems a very simple operation,
behind the scenes many things can happen.
This tutorial looks into this mechanism that is regulated by descriptors.
You will learn how a descriptor works and what kind of problems it can help to
solve.
Python properties are based on descriptors and solve one type of problems.
Descriptors are more general, allow more use cases, and are more re-usable.
Descriptors are an advanced topic.
But once mastered, they provide a powerful tool to hide potentially complex
behavior behind a simple dot.
In this tutorial you will:
- Learn how to use Python's descriptors to add new functionality to attribute access
- Acquired solid background knowledge on how descriptors work
- Work with practical examples for applying descriptors
- Learn when to use a property or reach for a descriptor
- Get to know how popular Python libraries apply descriptors for tasks such as
data structure access, REST-APIs, ORMs, and serialization
The WebAssembly Summit aims to bring together maintainers and users of Python with WebAssembly, to discuss the state of this ecosystem, existing challenges, and ongoing work.
- When: Monday, July 14th or Tuesday, July 15th (to be confirmed)
- Where: Prague Congress Centre (PCC), Room to be announced
- Who can join: Anyone with a valid in-person EuroPython 2025 ticket
Managing a database and synchronizing service data representation with the database can be tricky. In this workshop, you’ll learn how to use SQLAlchemy, a powerful SQL toolkit, to simplify this task. We’ll cover how to leverage SQLAlchemy’s Object Relational Mapper (ORM) system, and how to use ORM’s asyncio extension in your async services.
Participants will walk out of this tutorial having learned how to:
- Use SQLAlchemy for database operations in Python, enhancing the readability and maintainability of the code
- Build Python classes (ORMs) that represent the database tables
- Experiment with different relationship-loading techniques to improve querying performance
- Utilize SQLAlchemy’s asyncio extension to interact with databases asynchronously
The industry is abuzz with the term "Vertical Agents," yet there’s often little clarity on how Agents work. At its core, however, an Agent is simply a workflow designed to automate tasks by using environment tools and enhancing its ability to reason, plan, decompose, and execute a given task.
In this talk, we’ll explore the necessity of planning and reasoning in various industries and build a practical use case in the Education domain. The application will answer user questions based on provided academic notes, and if the information isn’t available, it will seamlessly search the web. The decision-making process—whether to use existing knowledge or external sources—is where an Agent's role shines. To define and manage a custom knowledge base, we’ll utilize a Retrieval-Augmented Generation (RAG) approach.
With Agentic RAG, the audience will gain clarity on routing concepts, learn how to design an efficient architecture and understand how the Thought-Action-Observation loop enables an Agent to function effectively. As for the technical aspect, we will use LlamaIndex for the routing with its ReAcT Agent and Qdrant as the vector database with Hybrid Search capabilities.
The Rust Summit aims to bring together various stakeholders of Python’s Rust ecosystem to discuss its current state, address challenges, and align on ongoing work.
- When: Monday, July 14th or Tuesday, July 15th (to be confirmed)
- Where: Prague Congress Centre (PCC), Room to be announced
- Who can join: Anyone with a valid in-person EuroPython 2025 ticket
CI/CD (Continuous Integration and Continuous Deployment) has become a fundamental part of DevOps, helping teams deliver code quickly and catch potential problems before they turn into costly production issues. Without a solid CI/CD process, developers often struggle with manual deployments, inconsistent environments, and unexpected bugs that slip through the cracks, causing frustration and unplanned downtime.
In this session, we will walk you step by step through setting up a dependable CI/CD pipeline using Python, Jenkins, TestContainers AWS, and Kubernetes. Starting with basic configurations, we’ll automate everything from running tests to building containers and deploying them on a scalable Kubernetes cluster. By writing simple Python scripts, you will learn how to streamline repetitive tasks and create a smooth release workflow. We’ll also take time to discuss common pitfalls and show how to troubleshoot them, so you feel equipped to handle real-world challenges.
Whether you’re new to CI/CD or looking to refine your existing DevOps skills, this tutorial aims to make complex workflows easier to grasp. Expect hands-on practice, clear explanations, and practical takeaways that you can apply in your own projects right away. By the end, you’ll see how using Python at each stage not only automates time-consuming tasks but also brings a new level of reliability to the entire deployment process.
Our goal is to help you build confidence in creating a pipeline that brings predictability to your releases, saves your team time, and keeps your applications running smoothly in production. If you’ve ever wanted to see how a proper CI/CD setup can transform the way you ship software, this is your chance to dive in and see it come to life step by step.
Whenever you use a dot in Python you access an attribute.
While this seems a very simple operation,
behind the scenes many things can happen.
This tutorial looks into this mechanism that is regulated by descriptors.
You will learn how a descriptor works and what kind of problems it can help to
solve.
Python properties are based on descriptors and solve one type of problems.
Descriptors are more general, allow more use cases, and are more re-usable.
Descriptors are an advanced topic.
But once mastered, they provide a powerful tool to hide potentially complex
behavior behind a simple dot.
In this tutorial you will:
- Learn how to use Python's descriptors to add new functionality to attribute access
- Acquired solid background knowledge on how descriptors work
- Work with practical examples for applying descriptors
- Learn when to use a property or reach for a descriptor
- Get to know how popular Python libraries apply descriptors for tasks such as
data structure access, REST-APIs, ORMs, and serialization
The WebAssembly Summit aims to bring together maintainers and users of Python with WebAssembly, to discuss the state of this ecosystem, existing challenges, and ongoing work.
- When: Monday, July 14th or Tuesday, July 15th (to be confirmed)
- Where: Prague Congress Centre (PCC), Room to be announced
- Who can join: Anyone with a valid in-person EuroPython 2025 ticket
Learn how to write blazingly fast and modern numerical code in Python by leveraging just-in-time (JIT) compilation for CPU’s and GPU’s and how to scale computations across multiple machines. Tailored for data scientists, researchers, and Python enthusiasts, this session will focus on practical applications of JAX, Numba, and Ray to optimise and parallelise your numerical code. These techniques have applications across multiple fields like machine learning, numerical simulations, or engineering applications. You can already forget low level languages like C/C++, Fortran or similar.
What You’ll Learn
- Optimising and Accelerating Numerical Code with JAX and Numba:
- Converting NumPy code to JAX/Numba.
- JIT compilation for speeding up Python functions.
- Automatic differentiation (JAX).
- GPU/CPU acceleration and vectorisation.
- Main limitations of JAX and Numba.
- Hands-on exercises combining JAX and Numba to optimise loops, linear algebra, and scientific calculations.
- Scaling Workflows with Ray:
- Introduction to Ray: Parallel, out-of core and distributed computing made simple.
- Managing distributed tasks, scaling workloads across CPUs/GPUs, and handling large datasets.
- Integrating JAX and Numba in Ray-powered workflows for end-to-end acceleration.
Who Should Attend?
Participants should have intermediate Python programming skills and basic familiarity with NumPy and linear algebra. No prior experience with JAX, Numba, or Ray is necessary.
Structure
- Hour 1: Foundations of JAX and Numba – JIT compilation, GPU acceleration, and their respective strengths.
- Hour 2: Hands-on optimisation: Writing high-performance numerical code with JAX and Numba.
- Hour 3: Scaling computations with Ray: Parallelising JAX/Numba workflows across machines.
Takeaways
- Understand when and how to use JAX and Numba for accelerating numerical Python code.
- Write scalable, high-performance workflows using Ray.
- Leave with ready-to-use examples and insights to apply in their own projects.
The decorator pattern is a functional pattern that Python developers leverage to write more modular and composable functions.
This means that your functions end up being shorter and more focused, which is good since a function should do one thing and it should do it well.
Then, you can use decorators to introduce extra useful functionality that is not part of the spec of the function.
For example, you can add caching, profiling, or logging.
Moreover, because you do this with decorators, you can reuse that logic for other functions.
In this hands-on tutorial you will learn how to determine when decorators should be used and how to write your own decorators.
This will help you write code that is easier to reason about and maintain.
By the time you are done, you will have implemented a dozen decorators, you will know the full anatomy of a decorator, and you will have explored common useful decorators from the standard library and more.
The Rust Summit aims to bring together various stakeholders of Python’s Rust ecosystem to discuss its current state, address challenges, and align on ongoing work.
- When: Monday, July 14th or Tuesday, July 15th (to be confirmed)
- Where: Prague Congress Centre (PCC), Room to be announced
- Who can join: Anyone with a valid in-person EuroPython 2025 ticket
Ever wanted to be on the other side of a presentation (behind the microphone, instead of being in the audience)? Is there something you learned that you could share, but don't know how or how to get your idea accepted? Would you like to get out of your comfort zone and improve your career? Do you avoid public speaking due to stage fright?
If you answered yes to any of those questions, then you are in the right place! In this presentation, I'm gonna show why you (yes, YOU! The person reading this) not only should and CAN present at EuroPython (or anywhere you'd like).
I'll start with some background on how I started being a speaker, met EuroPython and how my presentations improved over the years. Will then tackle myths and facts about giving presentations and share lot's of Dos and Don'ts about CFP submissions (both based on personal submissions, and reviewing submissions from others). I'll also talk about what to expect before, during and after a talk or workshop, and most important: getting your hands dirty by crafting your own talk (5 min or 10 minute long) - details in the outline.
Tutorial is open to everyone, and after attending it participants will have greater insights to improve for their next (or first) conference talk, or what they should work on to get it accepted. Useful not only for conferences, but professional improvement at work.
Git is a powerful version control system, yet for many developers, it can also be a source of frustration and anxiety. If you’ve ever worried about missing commits, failed rebases, or accidentally breaking your company’s repo and even losing two weeks’ worth of work, you’re not alone. Fortunately, with a solid understanding of Git’s core concepts and best practices, you can avoid these issues and work with confidence.
This tutorial provides a practical guide to Git, covering fundamental building blocks such as the Commit DAG (Directed Acyclic Graph), the differences between the working directory, staging area and repository, as well as distributed version control and Git Workflows. You’ll review the key commands and workflows for successfully contributing to any project, while focusing on understanding what’s happening behind the scenes. Through interactive exercises, you’ll develop an intuitive grasp of Git, master day-to-day actions, and even debunk some popular misconceptions along the way.
By the end of this tutorial, you’ll have a profound understanding of Git’s building blocks, enabling you to use it effectively—and never break a repo again.
The WebAssembly Summit aims to bring together maintainers and users of Python with WebAssembly, to discuss the state of this ecosystem, existing challenges, and ongoing work.
- When: Monday, July 14th or Tuesday, July 15th (to be confirmed)
- Where: Prague Congress Centre (PCC), Room to be announced
- Who can join: Anyone with a valid in-person EuroPython 2025 ticket
Learn how to write blazingly fast and modern numerical code in Python by leveraging just-in-time (JIT) compilation for CPU’s and GPU’s and how to scale computations across multiple machines. Tailored for data scientists, researchers, and Python enthusiasts, this session will focus on practical applications of JAX, Numba, and Ray to optimise and parallelise your numerical code. These techniques have applications across multiple fields like machine learning, numerical simulations, or engineering applications. You can already forget low level languages like C/C++, Fortran or similar.
What You’ll Learn
- Optimising and Accelerating Numerical Code with JAX and Numba:
- Converting NumPy code to JAX/Numba.
- JIT compilation for speeding up Python functions.
- Automatic differentiation (JAX).
- GPU/CPU acceleration and vectorisation.
- Main limitations of JAX and Numba.
- Hands-on exercises combining JAX and Numba to optimise loops, linear algebra, and scientific calculations.
- Scaling Workflows with Ray:
- Introduction to Ray: Parallel, out-of core and distributed computing made simple.
- Managing distributed tasks, scaling workloads across CPUs/GPUs, and handling large datasets.
- Integrating JAX and Numba in Ray-powered workflows for end-to-end acceleration.
Who Should Attend?
Participants should have intermediate Python programming skills and basic familiarity with NumPy and linear algebra. No prior experience with JAX, Numba, or Ray is necessary.
Structure
- Hour 1: Foundations of JAX and Numba – JIT compilation, GPU acceleration, and their respective strengths.
- Hour 2: Hands-on optimisation: Writing high-performance numerical code with JAX and Numba.
- Hour 3: Scaling computations with Ray: Parallelising JAX/Numba workflows across machines.
Takeaways
- Understand when and how to use JAX and Numba for accelerating numerical Python code.
- Write scalable, high-performance workflows using Ray.
- Leave with ready-to-use examples and insights to apply in their own projects.
The decorator pattern is a functional pattern that Python developers leverage to write more modular and composable functions.
This means that your functions end up being shorter and more focused, which is good since a function should do one thing and it should do it well.
Then, you can use decorators to introduce extra useful functionality that is not part of the spec of the function.
For example, you can add caching, profiling, or logging.
Moreover, because you do this with decorators, you can reuse that logic for other functions.
In this hands-on tutorial you will learn how to determine when decorators should be used and how to write your own decorators.
This will help you write code that is easier to reason about and maintain.
By the time you are done, you will have implemented a dozen decorators, you will know the full anatomy of a decorator, and you will have explored common useful decorators from the standard library and more.
The Rust Summit aims to bring together various stakeholders of Python’s Rust ecosystem to discuss its current state, address challenges, and align on ongoing work.
- When: Monday, July 14th or Tuesday, July 15th (to be confirmed)
- Where: Prague Congress Centre (PCC), Room to be announced
- Who can join: Anyone with a valid in-person EuroPython 2025 ticket
Ever wanted to be on the other side of a presentation (behind the microphone, instead of being in the audience)? Is there something you learned that you could share, but don't know how or how to get your idea accepted? Would you like to get out of your comfort zone and improve your career? Do you avoid public speaking due to stage fright?
If you answered yes to any of those questions, then you are in the right place! In this presentation, I'm gonna show why you (yes, YOU! The person reading this) not only should and CAN present at EuroPython (or anywhere you'd like).
I'll start with some background on how I started being a speaker, met EuroPython and how my presentations improved over the years. Will then tackle myths and facts about giving presentations and share lot's of Dos and Don'ts about CFP submissions (both based on personal submissions, and reviewing submissions from others). I'll also talk about what to expect before, during and after a talk or workshop, and most important: getting your hands dirty by crafting your own talk (5 min or 10 minute long) - details in the outline.
Tutorial is open to everyone, and after attending it participants will have greater insights to improve for their next (or first) conference talk, or what they should work on to get it accepted. Useful not only for conferences, but professional improvement at work.
Git is a powerful version control system, yet for many developers, it can also be a source of frustration and anxiety. If you’ve ever worried about missing commits, failed rebases, or accidentally breaking your company’s repo and even losing two weeks’ worth of work, you’re not alone. Fortunately, with a solid understanding of Git’s core concepts and best practices, you can avoid these issues and work with confidence.
This tutorial provides a practical guide to Git, covering fundamental building blocks such as the Commit DAG (Directed Acyclic Graph), the differences between the working directory, staging area and repository, as well as distributed version control and Git Workflows. You’ll review the key commands and workflows for successfully contributing to any project, while focusing on understanding what’s happening behind the scenes. Through interactive exercises, you’ll develop an intuitive grasp of Git, master day-to-day actions, and even debunk some popular misconceptions along the way.
By the end of this tutorial, you’ll have a profound understanding of Git’s building blocks, enabling you to use it effectively—and never break a repo again.
The WebAssembly Summit aims to bring together maintainers and users of Python with WebAssembly, to discuss the state of this ecosystem, existing challenges, and ongoing work.
- When: Monday, July 14th or Tuesday, July 15th (to be confirmed)
- Where: Prague Congress Centre (PCC), Room to be announced
- Who can join: Anyone with a valid in-person EuroPython 2025 ticket
Welcome to EuroPython 2025! Please notice the registration will happen on the Forum Hall Foyer on the 1st Floor.
You can pick up your badges at any time during the week as long as we are open!
If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!
Welcome to EuroPython 2025!
Join us on the opening session, where we will kick-off the conference days, and tell you what's going to happen in the following days.
You will have three days filled with Keynotes, talks, panels, and open spaces, lightning talks, and a weekend full of sprints and other events for people attending the conference.
Contributing to Python can feel intimidating, especially when it comes to areas like the interpreter or JIT compilation. A common misconception is that to get started, you need deep expertise in compilers or internals—but that’s not true. Some of the most impactful work in Python isn't about writing complex optimizations; it's about making things work across platforms, maintaining build systems, improving developer experience, and ensuring stability for millions of users.
In this talk, I’ll share my journey contributing to Python, from maintaining the JIT build system to maintaining parts of the standard library. I’ll highlight the often-overlooked but critical work that keeps Python running—from dependency management and build automation to API design considerations and documentation. If you've ever thought “ I’m not a compiler engineer, can I really contribute to Python?” —this talk is for you. By the end, you'll clearly understand the many ways you can contribute and why Python needs more than just compiler engineers to keep evolving.
Our mission is simple but profound: to improve and extend lives by learning from the experience of every person with cancer. Achieving this requires seamless feedback loops between scientists, engineers, and clinicians working with sensitive data across heterogeneous environments.
You might expect a story about how we tried and failed. And yes, we’ll share some failures and surprises along the way. But this is, at its core, a success story - because it works.
In this talk, we’ll dive into the data architecture and core technologies that enable us to learn from every patient’s journey with cancer. We’ll reveal how our cross-functional teams - scientists, engineers, and clinicians - collaborate to transform raw data into research-grade datasets. Along the way, we’ll share the challenges we faced, the lessons we learned, and the tools we developed to ensure the high data quality required for groundbreaking research.
We’ll also show how we leverage domain knowledge, data science, and established technologies to create tools that maintain this quality and accelerate feedback loops. By shifting insights generation left, we empower teams to iterate faster and drive more impactful outcomes.
This talk is ideal for anyone with data warehouse or lakehouse experience curious about harnessing the Pythonic data stack to iteratively generate insights from sensitive data in highly regulated environments.
Petabytes of unstructured data stand as the cornerstone upon which triumphant Machine Learning (ML) models are built. One common method for researchers to extract subsets of data to their local environments is by simply using the age-old copy-paste, for model training. This method allows for iterative experimentation, but it also introduces challenges with the efficiency of data management when developing machine learning models, including reproducibility constraints, inefficient data transfer, alongside limited compute power.
This is where data version control technologies can help overcome these challenges for computer vision researchers. In this workshop we'll cover:
- How to use open source tooling to version control your data when working with data locally.
- Best practices for working with data, preventing the need to copy data locally, while enabling the training of models at scale directly on the cloud. This will be demoed with an OSS stack:
- Langchain
-Tensorflow - PyTorch
- Keras
You will come away with practical methods to improve your data management when developing and iterating upon Machine Learning models, built for modern computer vision research.
How often do we trust our instincts when optimizing code? In Python, performance frequently defies intuition, leading us to make changes that might slow things down instead of speeding them up. This talk explores surprising truths about Python performance and showcases why measurement tools are essential for finding the real bottlenecks in our code.
Consider this: is it faster to count even numbers in a list using len([x for x in arr if x % 2 == 0]) or sum(1 for x in arr if x % 2 == 0)? While one might seem more Pythonic or efficient at first glance, the performance results might surprise you.
Through an interactive format, we’ll quiz you on performance scenarios using real-world examples. From counting even numbers to rewriting Python code in Rust, each case study will challenge assumptions about what makes code faster.
Plan:
- Introduction: Why intuition often fails in software performance
- Interactive performance case studies: Real-world examples that will surprise you
- Counting even numbers
- String concatenation
- Pathfinding optimization
- etc.
- Conclusion: How do we become consistent about optimizations?
By the end, you’ll understand why performance measurements matter and leave with practical insights and tools to improve Python performance systematically.
Python is slow: why? Can we make it faster?
Over the years, various answers to these questions have been given, and
in my opinion, many of those are partial, imperfect, or just plainly wrong.
The truth is that there is no simple answer. We will examine some of the most
common ones, and explain why they aren’t totally accurate. While doing so, we
will examine the current status of some of the techniques currently adopted
such as static typing, JIT, and AOT compilation, and explain why those alone
are not enough.
Finally, we will go deeper and try to understand what are the fundamental
issues to overcome, and what could be possible ways of moving forward.
Ask any successful software developer - it takes a lot more than technical skills to win at this game. Software development is a team sport.
What does good teamwork mean to you? Is it about empathy? Making sure voices are heard? Clear communication? Mutual respect? Well...yes.
But there is more to it than that. A lot more.
When it comes to software development, a lot of these fluffy definitions of good teamwork can be implemented in very concrete ways.
This talk will cover a lot of the "soft" skills that come into play in software development, as well as the harder skills that come into play (eg testing and proper use of Git). These are a few of the skills that will make people want to work with you again and again.
Prepare yourself for ball-sport analogies.
As data complexity increases, traditional analysis methods often fall short in uncovering hidden structures within datasets. How can we move beyond linear models to reveal the true shape of data? Topological Data Analysis (TDA) offers a breakthrough approach, yet it remains underexplored in the Python ecosystem. This session will demonstrate how TDA can be made accessible to a wider audience, showcasing its potential for discovering patterns that traditional methods miss.
Why is this interesting to the Python community?
Python is the go-to language for data analysis, but TDA is an underutilized tool that offers new insights, especially for high-dimensional or complex data. This session introduces TDA and explores two popular Python libraries—GUDHI and Ripser. Attendees will learn how these tools can uncover hidden structures in data that other methods, like clustering and dimensionality reduction, may overlook.
My Perspective on the Problem:
As a TDA researcher, I’ve used GUDHI and Ripser to analyze large, high-dimensional datasets, such as those from the Galaxy Zoo project. These libraries revealed topological features that deepened my understanding of data structure. I’ll compare GUDHI and Ripser, sharing practical insights into how they can be applied in Python to extract meaningful topological features from your data.
What will the audience take away?
Introduction to TDA: Learn the core concepts like persistent homology and simplicial complexes and how they reveal the shape of data.
Hands-On with GUDHI and Ripser: Discover how to compute persistent homology using GUDHI and Ripser, and integrate them into your workflow.
Practical Insights: Apply TDA to real-world data and uncover hidden patterns in high-dimensional datasets.
Comparing GUDHI and Ripser: Understand the strengths of both libraries and when to choose one over the other.
Applications Beyond Machine Learning: See how TDA complements clustering, dimensionality reduction, and opens up new possibilities in all fields.
A semantic search on a website is the best way to make its content easily accessible to users because it interprets the meaning of words and is in fact increasingly used with the growth of AI technologies.
The implementation of semantic search can be complex and many adopt the strategy of using dedicated vector databases, in addition to the database, but this strategy has architectural and performance issues.
In this talk we will see a Pythonic way to implement semantic search on a website using a purely Open-Source AI stack (Python, Django, PostgreSQL, pgvector, Sentence Transformes). We’ll analyze some issues of using external vector databases with examples from my experience.
Through this talk you can learn how to add a semantic search on your website, based on Django and PostgreSQL, or you can learn how to update the semantic search function if you use other vector databases.
In this talk, we will explore the world of Just-In-Time (JIT) compilation within the CPython interpreter. As Python continues to grow in popularity, performance enhancements are crucial to meet the demands of modern applications. The new CPython JIT implementation represents a tool for pushing Python's performance forward in a scalable, maintainable way.
I will start by exploring the mechanics of JIT compilation, explaining how it differs from traditional interpretation. Next, I will provide an overview of the current state of the CPython JIT in Python 3.14, highlighting its latest advancements and performance improvements. I will also briefly touch on my personal contributions to this project. By sharing these insights, I aim to inspire others to engage with open-source projects and contribute to the ongoing innovation within the Python ecosystem.
Finally, we will discuss practical applications of the CPython JIT and how you can enable it in your applications. Attendees will gain a clear understanding of how the JIT dynamically translates Python code into machine code at runtime using the CPython 3.14 implementation as reference and will learn how to use the JIT on their own Python applications.
As AI becomes a more significant part of our everyday lives, ensuring these systems are fair is more important than ever. In this session, we’ll discuss how to define fairness and the potential harms our algorithms can have on people and society. We’ll introduce fairlearn, a community-driven, open-source project that offers practical tools for assessing and mitigating harm in AI systems. We’ll also explore how to discuss bias, different types of harm, the idea of group fairness and how they all relate to fairlearn’s toolkit. To make it all concrete, we’ll walk through a real-world example of assessing fairness and share some hands-on strategies you can use to mitigate harm in your own ML projects. The tools fairlearn provides can be integrated into your existing scikit-learn pipelines.
Before an aircraft takes off, it is necessary to take into account an immense amount of variables: weather conditions, distance, take-off weight, fuel required, passengers, cargo… And so on. Using this data to plan the individual flight and ensuring a safe trip is part of a Flight Dispatcher’s daily duty. To top that, there is a high chance that the flight has several last-minute changes, which increases its difficulty widely. The most common issue is that the prediction of passengers increases significantly minutes before the flight finally takes off. This means more weight and more fuel to lift the plane: a single error and the passengers and cargo will be left on the ground, with all costs and damages involved. Nowadays it is a manual job, even though there are a lot of areas that can be calculated automatically, but with the expansion of data analysis technologies, this matter can be improved greatly.
This talk aims to display which tools are currently used in this area, for which purpose, and how said new technologies can make a Flight Dispatcher’s life a lot easier and efficient. A proposal will also be presented to make this a reality with Python. This will work as an application that can process all the data involved of the last couple of months and estimate the number of passengers, taking into account the date, time and destination of that exact flight. The main achievement of this presentation is to show how the daily flight operations work and make it accessible for everyone interested in a fascinating sector that is still growing.
Last year at EuroPython, I gave a talk about leading with imposter syndrome, because let’s be honest, most of us feel like imposters when someone calls us “experts.” This year, I’m diving into something that helped me fight those feelings - mentoring both ways!
In this talk, we’ll explore how mentoring isn’t just about helping others. It’s also a wonderful way to level up your own skills. Whether you’re guiding someone who thinks print() is magic or learning from someone who uses five monitors and dark mode, mentoring both ways will change how you grow in your journey.
dbt (Data Build Tool) is a framework written in Python for creating, building, organizing, testing and documenting data models, i.e. data sets living in a database or a data warehouse.
dbt builds on clean software development practices to allow data engineers and analysts to focus on the core logic of their data transformations, while allowing them to manage datasets at scale.
Following a long-standing tradition in data engineering, dbt makes an extensive use of YAML to store metadata. Such metadata includes for example column types, table documentation, data correctness tests, 3rd party integrations, and any custom metadata that may be useful. In large projects, the metadata can easily amount to millions of values.
This is where things become complex, as there's no mechanism to ensure the correctness and consistency of this metadata. In particular, answering the following questions is hard:
- Is this table sufficiently tested?
- Does this table expose sensitive data?
- Does this column name follow naming conventions?
Answering those questions is essential to maintain a high quality of data, as well as secure it by safe-guarding it against incidental exposure and other privacy and compliance concerns.
This is why we created and open-sourced dbt-score, a linter for dbt metadata. It is designed to be flexible to enforce and encourage any good practice set up by data teams. Through its CLI, data practitioners can easily obtain a maturity score of their data models, keep the metadata chaos manageable, improve consistency, and eventually deliver high-quality data.
This presentation will cover:
- An introduction to dbt
- The importance and advantages of declarative, git-tracked metadata
- The need for linting this metadata
- How dbt-score tackles this challenge, and its applicability to diverse dbt projects
More information about dbt-score can be found online:
- Documentation: https://dbt-score.picnic.tech/
- Source code: https://github.com/PicnicSupermarket/dbt-score
Python’s performance has always been a hot topic. A new experimental JIT compiler was released in Python 3.13. PyPy, with its tracing JIT, has been around for a long time, and GraalPy, with a more traditional method-based JIT approach, has recently been gaining traction in the community. We will take you on a tour of these JIT compilers, offering a sneak peek under their hoods. We will examine what kind of Python code can benefit most from JIT technology and what kind of code will not benefit at all.
Beyond the current landscape, we’ll also look into the future of JIT compilation in Python. Have you ever rewritten Python code in C because it was too slow? What if we told you that in the future, this might not be necessary? What if we told you that rewriting to C might actually slow down otherwise performant Python code? How does HPy, the alternative Python C API, fit into this picture? And if that isn't enough, we will also cast some predictions about what may happen when JIT meets free threading—aka no-GIL 💣.
Wrapped has become one of the most widely anticipated data analytics dashboards of the year. But what happens when the results aren't as complex (or accurate) as people were expecting? Data scientists come in to save the day!
Using elasticsearch and kibana I will be creating my own musical trends and insights using the user generated data - that you can also download and follow along with!
From queries, filters, and aggregations to visualizations, time series analysis, and brat summer - we will explore how search analytics can be used for everyday cases.
It's no secret that open source maintenance has its dark sides, and one of these is having to sometimes interact with quite ungrateful, entitled or outright toxic people. As a project's popularity increases, so does the frequency of this kind of interaction, adding to the burden shouldered by maintainers and possibly becoming a significant risk factor for maintainer burnout.
I've been maintaining a quite popular project for over 12 years straight now, and had to develop the one or other coping strategy to deal with these interactions, in order to not let them drag me down and negatively affect my motivation and mental health. In this talk I want to first give a classification of the most common forms of bad and toxic behaviour I've seen in my day to day, and then share my personal approach to dealing with them, explaining why this has worked for me along the line.
In the end, the viewer should take away some concrete advice on how to handle possibly volatile interpersonal situations in the context of an open source project (and hopefully also beyond), without compromising on their own mental well-being.
With the rise of LLMs, prompt engineering has become a highly impactful skill in the AI industry. However, manual prompt tuning is challenging, time-consuming, and not always generalizable across different models. This raises a reasonable question: can prompts be automatically learned from data? The answer is yes, and in this talk, we will explore how.
First, we will provide a high-level overview of various prompt optimization approaches, starting with a simple technique like bootstrapped few-shot, which automatically generates and selects an optimal set of demonstrations for each step in the LLM chain. Then, we will discuss more complex approaches, such as MIPRO and TextGrad, which directly optimize the instructions.
Afterwards, we will move on to a more practical part by showcasing how these techniques can be used via popular frameworks such as DSPy and AdalFlow.
Finally, we will discuss the benefits and trade-offs of these approaches and frameworks in terms of costs, complexity and performance, so the audience can decide whether prompt engineering is truly dead.
Target Audience
This talk will be particularly interesting for people working with LLMs. Some familiarity with the domain will be beneficial.
Key Takeaway
Challenges with manual prompt engineering and potential solutions provided by automatic prompt optimization techniques.
In this talk, we will look at the relationship between Python and SQL, highlighting the journey of data management in modern applications. As data continues to grow exponentially, the need for effective data storage and retrieval becomes necessary. We will begin by discussing the foundational role of SQL (Structured Query Language) in managing relational databases, examining its key features and common use cases in various domains.
We will then explore the challenges Python developers face when interacting with SQL databases, including the complexity of SQL syntax and the boilerplate code required for CRUD operations. This will be illustrated with practical examples, demonstrating how raw SQL can become cumbersome in application development. Raw SQL, while powerful, can introduce significant challenges in terms of development time, maintainability, and productivity. These challenges stem from the need to write and maintain complex SQL queries, deal with database-specific syntax, and manage the boilerplate code associated with database interactions.
To address these issues, we will pivot to Object-Relational Mappers (ORMs) as a solution that fills the gap between object-oriented programming & relational databases. We will discuss the evolution of ORMs, their key features, and how they simplify database interactions by allowing developers to work with Python objects instead of raw SQL queries, thus alleviating the challenges associated with raw SQL such as the complexity of SQL syntax, boilerplate code, and the need to manage database-specific nuances.
We will also explore popular ORMs such as SQLAlchemy, Django ORM, Peewee, and Tortoise-ORM, highlighting their unique capabilities and use cases. Finally, we will compare the scenarios in which raw SQL is preferable versus when ORMs are more beneficial, providing insights into making informed decisions on a case-by-case basis.
This session will deepen your understanding of the relationship between Python and SQL, and the evolution of ORMs in modern application development.
If you don't have vision problems, you probably don't know what a screen reader is; or maybe you know that it is a program that visually impaired people use to operate a computer or mobile phone. Perhaps you have even watched a demo or a blind person using it, but that only confirms that screen readers are not made for you and that they won't offer you anything. In this talk, I want to show you how wrong that thought is and the many ways you can take advantage of these tools even if you have perfect vision.
NVDA is an open-source screen reader for Windows based on Python. In addition to the built-in functionalities in its core, NVDA also provides an add-ons system that allows Python developers to extend its capabilities far beyond its original purpose.
Through a set of libraries and APIs, you can easily access system objects and events, manage keyboard shortcuts and touch or pointer gestures, play sounds, handle the clipboard or the screen, and even create complete applications by integrating your own Python libraries. This combination of power and flexibility makes NVDA the perfect platform to automate tasks or add all kinds of utilities to the system that will increase your productivity and make your digital life much easier.
And, by the way, maybe I can inspire you to join the Fellowship and encourage you to share your add-ons with the NVDA community so that other visually impaired people can also benefit from your creations 😉 Join me and discover everything you can do with NVDA and Python!
Which LLM provider should you choose based on latency?
As LLMs become integral to modern applications, speed can make or break your UX. This poster highlights the performance trade-offs of OpenAI, Anthropic, local models, and other providers.
I will show how different models and providers perform across key metrics, helping you determine which option delivers the best user experience. I will show not only the raw numbers but also how each metric influences user perception.
We will measure:
- Time to first token
- Time to last token
- Latency variability throughout the day
- How structured responses affect performance
We will evaluate:
- State-of-the-art models
- Open-source models hosted by cloud providers
- Local models you can run on your own infrastructure
What you will learn
- Which model to use based on its latency
- How does prompt caching affects performance
You’ll have a clearer view of which solution fits your needs and how to balance performance, costs, and practical considerations.
The Unified Acceleration Foundation (UXL), under the umbrella of Linux Foundation, is driving an open standard accelerator software ecosystem that includes compilers and performance libraries. This software ecosystem standardizes programming different types of accelerators, such as multi-core CPUs, GPUs, some FPGAs, etc. from different vendors. This poster presents the ongoing work to extend the UXL software ecosystem to Python. The UXL Python ecosystem enables building portable, data-parallel Python extensions using standard Python tooling using scikit-build, meson and popular extension generators such as Cython or pybind11.
We showcase sample Python extension that can target multiple types of accelerators in the same Python session, including NVIDIA, AMD, and Intel GPUs.
In 2024, PySchool hosted three successful events, reaching over 100 high school students in Valparaíso, Chile. The main goal of PySchool is to make programming education more accessible and spark interest in STEM (science, technology, engineering, and mathematics). By showing students that learning to code is not as hard as it might seem, PySchool helps them consider STEM careers, even if they didn’t have role models or prior knowledge of programming.
The focus of the program is to make coding fun and easy to understand. Workshops are interactive and give students real coding challenges. They have access to an online platform where they can start coding right away, without needing to install anything. This hands-on approach helps students build practical skills and confidence in using Python, making it easier for them to continue learning.
PySchool has had a positive impact, with students giving the program a Net Promoter Score (NPS) of 9.3/10. This shows that students are very satisfied and would recommend it to their friends.
PySchool was created by members of Python Chile organization, with support from the Python Software Foundation and DUOC UC. PySchool was built having high school students with no Python knowledge as attendees, to complement other Python events like PyCon and PyDay, which are aimed at adults with prior Python knowledge.
Currently in the video game industry there are many tools for developers: Unreal Engine and Unity are the most famous. The learning curve for Unreal Engine is step enough for people to look for simpler alternatives and Unity has made controversial decisions and has generated discontent among the developing communities. For these reasons, Godot, which allows using Python to make professional games, has become more and more used since 2023. The advantages of this engine are: it is open source, it occupies few megabytes, it comes with an integrated editor and documentation and uses a scene architecture based on SOLID principles. In this talk, we will see how to create a step-by-step basic game to show Godot capabilities, together with the simple and easy-to-use interface the module provide. We will set a character that moves within the screen and will have to collect items while dodging enemies. Making games is a lot of fun, and Godot+Python is a very good option to make prototypes or complete games.
Documentation is crucial for the development and growth of any project. If you know English, you're lucky; most technical knowledge is in that language. But what about those who don’t? 😢
A few years ago, the official Python documentation wasn’t available in Spanish, creating two main challenges:
- Many Spanish speakers with limited English skills struggled to access the documentation.
- Translation efforts were fragmented, with different communities attempting partial translations.
Offering the official Python documentation in Spanish provides the global Spanish-speaking community with the opportunity to access it directly, without needing a second language; it also creates bonds of identity among those who join the collective exercise of explaining and translating the documentation's concepts. It generates identity and community!
In this talk, we'll share the journey of Python-Docs-ES, the lessons learned from nearly 230 contributors, and how you can join in, whether in Spanish or in your own language.
Contributing to Python doesn’t always mean writing complex code, it can also mean making knowledge accessible to more people. 💡✨
Writing code from scratch, especially with recent progress in AI, has never been easier, however maintaining and fixing the code as your codebase grows has been and still remains one of the biggest challenges.
I'll go over practical advice on programming something that will make your team's and your life easier in years to come instead of be the constant source of frustrations.
From Python’s new type parameter syntax and exception groups to structural pattern matching and assignment expressions, these are only a few of Python’s multitude of syntax features that all of us can use to make our lives easier.
But have you ever thought about what it takes to implement these features? How does your source code get transformed, so that Python knows what to do in order to produce the output that you expect (or not)? The tokenizer, the parser, the bytecode compiler and the interpreter are all pieces to the puzzle of how Python does its magic.
In this talk, we’ll look behind Python’s curtains and try to understand together how the CPython implementation takes in your source code, generates a token stream, creates from it an Abstract Syntax Tree, emits bytecode and finally interprets that bytecode to run your programs. And who knows? Maybe you’ll get to hear about some new and shiny syntax features as well!
Have you ever published a project under an open-source license? If so, do you know if it’s used downstream? Has it been packaged to a Linux distribution? Who brought it there, and who maintains it? What are the needs of someone integrating your project into their ecosystem - be it an operating system or an environment manager, like conda? Have you ever wondered how projects appear from that perspective? I won’t be offended if the answer is: “Well, no, why would I?”
That’s the blind spot I’ll address in my talk. I’ll share the unique perspective of a person who has worked with thousands of Python projects and integrated them into an operating system.
You’ll learn:
- Which project features make a packager’s life easier - and which make it harder,
- Whether tests are a blessing or a curse (and when),
- Why we care about the package metadata and included contents so much,
- How to simplify the process for others to contribute to your project,
- What are the challenges package maintainers face,
- And how downstream packagers can enrich your project.
My talk will bridge the points of views of both the project authors and downstream integrators, and will offer a set of good practices you can consider adopting.
About me: In my job, I integrate over 4000 Python packages into Fedora Linux with every new Python release, from the first alpha to a final version - a process that spans an entire year. I’ve seen a lot.
About you: If you’ve ever written a small application or library, packaged it and published it on PyPI, or even considered doing it, you’re the target audience of this talk. No specific prior knowledge is required beyond creating Python projects and publishing them via version control systems.
Does the mention of binary tree traversals or re-implementing established sorting algorithms make your eyes roll? You are not alone. Coding interviews are a core part of Python careers, yet they’re often a tiring and stressful experience for both parties. Candidates leave demoralized, interviewers gain little insight, and the cycle repeats. But what if interviews could teach while they test?
Drawing from personal failures and successes on both sides of the table, this talk offers a roadmap of ideas to transform Python technical interviews into collaborative, fun, and skill-building conversations. We’ll cover common traps and explore ideas for practical, more enjoyable replacements.
As a Python community, we’re all interviewers and interviewees at some point so we all share the responsibility to make interviews a better experience and ensure everyone leaves the meeting smarter, with horizons broadened. By reframing interviews as shared learning experiences, we can reduce anxiety, improve hiring outcomes, and strengthen the Python community—one interview at a time.
In this lecture, we will explore the evolution of Python monitoring over the years, covering tools and techniques from sys.monitoring to import hooks, highlighting advancements and best practices in keeping your Python code in check.
As an engineer attending this talk - you will be able to understand the different monitoring mechanisms used by OpenTelemetry, PDB and other observability and monitoring tools, as well as a practical decision making framework on how to choose the best one to tailor your needs.
Once upon a type in Pythonland, we would say:
If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck."
Then the type-checking team started scoring multiple goals.
Is type-checking useful in Python? What about existing codebases? Recommendations and pitfalls.
In this talk, we'll take a look at:
- why should you typecheck your code? what are the benefits and drawbacks?
- how can you do that without stopping development, but without chasing an ever-changing target?
- what are the pitfalls from type checking - can it provide a false sense of security?
- How to interact with third party libraries?
- Is static type-checking enough, or do we need to runtime check as well?
- Is the type checker always right?
This is a case study about how it was done (and is still being done) on a real, large production codebase at Aiven. This is not a theoretical talk - I'll try explaining what are the major pitfalls, what problems were solved and what problems were introduced by type checking.
And I'll finally answer The Big Question: would you do that again?
In this talk, we’ll explore how WebAssembly enables running Python in isolated and scalable environments. We’ll look at practical use cases, from serverless function execution to sandboxed environments, and how tools like wasmtime, wasmer, and Pyodide make this possible. Will also try to cover comparisons to show where WASM shines, and where it still falls short for Python developers today.
Traditional serverless platforms rely on containers (like Docker), which have overhead in terms of cold start times, resource usage, and security risks. WASM provides a lightweight alternative that allows faster execution, stronger isolation, and cross-platform portability.
However, Python was not designed for WASM. It relies on system calls and C-based extensions, which makes running it in a WASM runtime tricky. This talk will address how to bridge that gap and bringing around Python in the WASM ecosystem.
Outline:
- WASM vs. Containers – Why WASM is faster, more secure, and better suited for serverless workloads.
- Python’s Challenges in WASM – System call dependencies, native extensions, and performance trade-offs.
- Making Python Work in WASM – Running Python using Pyodide, wasmtime, and wasmer for lightweight APIs and ML inference.
- Deploying a FastAPI function in a WASM runtime and benchmarking it against a traditional serverless container.
OpenTelemetry Python instrumentations may seem indistinguishable from magic: they can be bootstrapped from your installed dependencies, they are able to patch your code without even noticing and most often they work out of the box automatically! Fortunately there’s no magic spell involved and they are mostly the combination of not well known Python features, standing on the shoulders of powerful libraries and work done by the community to improve the reach and the quality of the code.
In this talk we’ll see:
- how opentelemetry-bootstrap is able to install instrumentations for your installed libraries
- how opentelemetry-instrument leverages the sitecustomize module for providing auto-instrumentation
- how entry points can be used for components discovery
- how instrumentations are able to patch third party code
Let’s dig a bit into the code to see what’s inside the black box.
The EU AI Act, partly in effect, is a groundbreaking regulatory framework governing AI systems based on perceived risk. This talk covers the basics and explores lesser-discussed aspects, including implementation entities, the private sector's role, and exemptions for high-risk government and law enforcement use cases.
The AI Act categorizes AI systems into groups based on potential harm, with unacceptable risk systems like social scoring and mass CCTV facial recognition being prohibited. High-risk systems, such as biometric identification and employment management systems, must meet stringent obligations.
Surprisingly, the Act exempts many high-risk government and law enforcement use cases, including national security and border control, raising concerns about AI misuse. Additionally, AI systems used for research, development, or military purposes are not regulated, highlighting the need for complementary safeguards.
The implementation ecosystem is complex, with the European Artificial Intelligence Board as the central hub. National supervisory authorities and the European Commission play crucial roles in enforcement and cooperation. Notified bodies, assessing high-risk AI systems, offer engagement opportunities for the private sector.
The AI Act also introduces regulatory sandboxes, allowing developers to test innovative AI systems under supervision. These sandboxes foster innovation while minimizing risks, providing opportunities for startups and established companies.
In conclusion, the EU AI Act is a comprehensive framework with a complex implementation ecosystem and private sector engagement opportunities. However, exemptions for high-risk use cases spark debates about its scope and effectiveness. Understanding these aspects is crucial for navigating the AI Act's regulatory landscape and fostering responsible AI innovation.
Learning to code has never been more accessible, with countless online courses, video tutorials, and bootcamps available to aspiring programmers. Yet, despite the abundance of resources, many capable learners are filtered out—not because of their abilities, but because traditional curricula fail to account for the unique challenges faced by neurodiverse individuals. As a neurodivergent educator and curriculum designer, I’ve witnessed firsthand how the disconnect between learning strategies and learner needs can derail even the most motivated students.
This talk explores how current teaching techniques and evaluation methods unintentionally exclude neurodiverse learners, despite many of the qualities associated with neurodiversity aligning with traits prized in programmers. Using insights from my own teaching experience, I’ll share practical solutions for designing inclusive curricula and fostering learning environments where neurodiverse students can thrive. We’ll also discuss self-advocacy strategies for neurodivergent learners and ways family, friends, and educators can support their success.
Ultimately, this talk demonstrates that by addressing the needs of neurodiverse learners, we can create programming education that benefits everyone—promoting inclusivity, innovation, and opportunity for all.
PyScript is an open source platform for Python in the browser.
EduBlocks is a block-based tool for teachers, students and anyone taking their first steps in coding. The educational "blocks" we use, actually create Python.
But where do you evaluate the user's code? We used to use a hosted service where Python was evaluated in the cloud. Now, thanks to PyScript, everything runs in the user's browser.
In this talk, we'll explain how it works and show you how to run Python in your own browser-based applications.
It turns out PyScript is really great for Python as an edge-computing environment in the browser.
I developed poliastro, an open source library for interactive Astrodynamics in Python, for almost a decade.
Seemingly everything was going well: GitHub stars were going up, I got a regular stream of grant money, users were happy, some companies were using it...
And then at one point I decided to step down as a maintainer. What happened?
Many Python developers have added type hints and run mypy checks, but still rely on typing.Any too often, keep old typing.List/typing.Dict hints, or use # type: ignore comments everywhere. In that case, typing may feel like just another task, not a tool that truly improves quality.
But like unittest, typing can reduce hidden issues and make you confident about changes, even though it does not add new features directly. If we maintain and improve our type hints over time, typing can become a reliable foundation for your project, making refactoring safer and Python upgrades smoother.
This talk is not just another basic intro. We’ll show practical steps with before-and-after code examples:
- Use ideas from newer features (like typing.TypeIs in Python 3.13) and typing_extensions to apply similar concepts on older versions.
- Run pyupgrade (via ruff) to automatically update old hints, reducing manual edits and creating a consistent style.
- Apply partial ignores instead of full # type: ignore, and integrate pre-commit and CI checks to catch issues early, making typing checks feel natural.
- Add types to example code to detect subtle incompatibilities, similar to how tests find hidden bugs.
We’ll also propose a gradual approach so your team won’t be overwhelmed. After this talk, you should see typing as a stable base that reduces bugs, helps with refactoring, and supports long-term growth.
Who should attend this talk?
This talk is for intermediate Python developers who already use basic type hints but feel they are not getting enough value out of them yet. If you want to go beyond minimal checks and keep your typing strong as your project grows, this session will show you practical steps you can take.
Deploying machine learning models for real-world tasks is expensive—especially for inference. Unlike training, inference isn’t a one-and-done deal; it’s a recurring cost that grows with every prediction you make. And naturally, if you want accurate results, you’re probably calling up the biggest, most powerful model in your arsenal. But here’s the problem: these large models are resource-hungry, and most inputs don’t even need their full power. In fact, research shows that small, efficient models can handle a good chunk of your tasks just fine.
So why bring a Ferrari to pick up groceries? Adaptive inference offers a smarter solution: instead of using one oversized model for everything, it dynamically selects which model to use based on task difficulty. For simple inputs, you call smaller, cheaper models. For harder tasks, you escalate to the big guns. The result? High accuracy without blowing your compute budget.
This talk will cover:
- Why using one large model for all tasks is overkill (and expensive).
- How adaptive inference works and practical strategies for task routing.
- Challenges in estimating task difficulty and balancing latency with accuracy.
- Real-world examples of cost savings, from edge-to-cloud setups to large language model APIs.
To make this tangible, I’ll share how Agreement-Based Cascading (ABC) uses ensemble agreement for routing decisions. By letting models decide when they’re needed, ABC saves costs in edge-to-cloud deployments, reduces GPU rental and API bills, and outperforms state-of-the-art methods—all while staying intuitive and efficient.
Whether you’re an ML engineer deploying models, a researcher curious about efficient inference, or just someone who loves learning how to save money while staying performant, this talk has something for you.
CI/CD Pipelines are an essential part of modern Software Engineering, for everything from hobby projects to professional teams. But, when things go wrong, the mixture of single-purpose code, proprietary runtimes and third-party plugins can make reasoning about issues incredibly difficult and reproducing them almost impossible. What we want instead are processes that can run consistently in any environment, making them easier to maintain and debug.
As a powerful cross-platform scripting language, Python might seem an obvious candidate. But, versioning and dependency management have typically stood in the way.
Building on recent improvements like per-script requirements (PEP 722), and modern project management tools like hatch and uv, this talk will demonstrate how to leverage Python to create automation that runs natively everywhere. In particular, we’ll show:
- How virtualenvs and modern tooling can handle everything from dependency management to managing Python versions
- How to leverage libraries to create cross-platform automation (and when to fall back on
subprocessand the host environment instead) - How to structure your pipelines to run (almost) identically locally and in the cloud
While most directly applicable to DevOps workflows, we will discuss principles that can help any Python developer easily manage their environment and dependencies, and build pipelines to support their work.
For DevOps engineers, the aim is to avoid extra complexity and create clear, inspectable and maintainable pipelines by showing how much you can build with the tool you already have: Python!
Many schools, especially in developing regions, face challenges in delivering quality Computer Science education due to limited access to proprietary software and resources. Open-source software (OSS) offers a powerful alternative, yet its adoption in classrooms remains slow due to various barriers, including lack of awareness, training, and institutional support.
In this talk, I will share insights from my research on how Computer Science teachers in Namibian schools are integrating open-source tools like Python, Scratch MIT into their lessons. I will discuss the benefits of OSS in education, the challenges teachers face, and practical strategies for overcoming these barriers.
By the end of the session, attendees will gain a deeper understanding of how open-source tools can make Computer Science education more accessible and engaging. Whether you're a teacher, developer, or advocate for open-source learning, this talk will provide practical takeaways for promoting OSS adoption in schools.
This talk will review Python's latest type hint features, especially those in 3.13/3.14. These features can improve development efficiency, catch bugs earlier, and improve code maintainability—all while writing less code. This talk will show how to leverage these hints to catch bugs earlier, write more transparent code, and make your development environment work harder for you.
We'll also look at practical examples that show how modern type hints can improve your development workflow without making it too complex, as simple is better than complex :)
This is a placeholder for the keynote abstract by Petr Baudis.
The content of the abstract will be add later on, so stay tuned for the change in the title and abstract.
The content will be available in https://europython.eu and don't forget to follow us on social media and follow our Newsletter.
Enjoy Wednesday's lightning talks! Short talks about everything by everyone.
Lightning talks are 5 minute talks that anyone participating at the conference can submit.
If that talk gets selected, you will have the chance to jump into the main stage and show us your project, your ideas, something you have learned, something you are proud of that's helping and contributing to our conference and community, or something else!
Be aware: there is a hard-limit on the 5 minutes, you cannot go over, because the host and audience will interrupt you.
Welcome to EuroPython 2025! Please notice the registration will happen on the Forum Hall Foyer on the 1st Floor.
You can pick up your badges at any time during the week as long as we are open!
If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!
Welcome to the second day of conference!
Yesterday was an amazing day, but for sure you don't remember all the things that were mentioned during the opening.
Join us to get an update and few more announcements. Come by and find out what is going to happen today.
Work started on a lock file specification for Python in earnest on 2021-01-31 and culminated in PEP 751 being accepted on 2025-03-31! While it's great that a conclusion was reached, why did it take 4 years to go from idea to acceptance? Because Python packaging is, in a word, hard.
The flexibility that Python packaging provides has led to over 600,000 projects on PyPI and Python becoming the glue language of the internet, but at the cost of some complexity and not having "one tool to rule them all". This talk will cover why Python packaging is hard and how that played into creating a lock file specification. The history of the spec and what it provides will also be covered.
Have you ever needed to debug a Python application in production without stopping it? While tools like GDB make this straightforward for C/C++, Python developers face unique challenges when attaching debuggers to live processes. This talk introduces PEP 768, a new proposal for Python 3.14 that adds a safe, zero-overhead debugging interface to CPython.
We'll explore how the current landscape forces debugging tools to use unsafe methods that can crash interpreters and corrupt memory. Then, we'll detail how PEP 768 solves these problems by introducing a cooperative debugging protocol that works with the interpreter rather than against it.
You'll learn why attaching debuggers to Python processes is uniquely challenging, how PEP 768 enables safe debugging through interpreter cooperation, the technical details of the zero-overhead implementation, real-world applications, including live process attachment for pdb and all about the security considerations and safeguards.
This talk will be particularly valuable for tool developers, system administrators, and anyone interested in Python internals or debugging techniques. You'll walk away understanding the challenges of live process debugging and how PEP 768 elegantly solves them.
Transitioning machine learning models from development to production can be challenging. This talk demystifies the deployment process, offering a comprehensive guide to getting your models into production environments securely and efficiently. We'll explore various deployment strategies, including containers, serverless architectures, and dedicated ML platforms. Learn about best practices for monitoring, scaling, and maintaining your models post-deployment. By the end of this session, you'll be equipped with actionable insights and tools to deploy your models confidently and ensure they deliver real-world value.
Playing your musical instrument through a Raspberry Pi programmed in Python to add effects in real time might seem like an unrealistic idea. Yet I've been using such a setup for hundreds of hours of rehearsals and gigs and it works great!
It's even relatively easy to do... provided you find the right combination of hardware, OS, libraries and configuration.
In this talk, we will show how using python with the powerful pyo module allows for quick and easy implementation of real-time audio processing chains, allowing for exploration of various effects like delay, wah, distortion, etc. We will also propose an overview of all the technical details involved in making a self-contained headless unit (hardware and OS selection, system configuration, headless user interaction, ...)
Whether you want to experiment with your latest idea of the best delaystortionverb pedal ever, or process the sound of an unusual instrument, or simply take pride in playing through FX's you designed yourself, this talk will offer you insights and guide you towards achieving your goal.
Even if music is not (yet) your jam, you’ll see that real-time digital signal processing (DSP) in Python is perfectly feasible, and uncover new paths for experimentation and exploration.
And if you are passionate about music, you might enjoy discovering the harpejji, a new instrument built like a guitar but played like a keyboard, that was the original use case for the developments presented here.
Open-source communities are often distributed around the world which presents a challenge to fostering effective communication and consensus building among its members. As the project and community grows, the challenges around facilitating effective communication only become more difficult.
Thankfully, there are a myriad of tools and methodologies available to deal with these challenges. During this talk, I will cover three ways both large and small open source communities can tackle these communication issues: project chats and message boards, regular project meetings and project enhancement proposals.
We'll look at a variety of open-source projects in the Python ecosystem to see exactly how they make use of these tools to solve the problem of distributed communication. I'll also share my own personal experiences with the conda package manager project how our community communicates across two continents.
Cython is a well-established tool that lets you generate low-level, quick C/C++ code from Python-like syntax, letting you blur the boundary between an optimized C/C++ layer and the Python code that uses it. Cython has long had the ability to write parallel code and this has become increasingly important with recent support for both subinterpreters and for freethreaded Python.
Firstly in this talk I aim to provide a general overview of what's available in Cython and how you can use it.
* Most obvious is Cython's inbuilt "prange" mechanism - a high-performance way of handling loops with independent iterations but not a general parallelization solution.
* Second (and often neglected) you can use Python's own threading module - the key here is to ensure that the Cython code that it calls is performant.
* Third, you have easy access to the C++ standard library and the threading tools that this exposes. My advice here is that the synchronization tools are nice, but using C++ to create new threads requires care.
* Finally there are “subinterpreters” which provides isolation between parallel processes both as a pro and a con. Since this is new to Cython (and not yet widely used in Python) there are limitations and pitfalls. I'll also discuss future plans, and some details of the current implementation in Cython.
Secondly in this talk I will cover "what's new". This is mostly improvements targeting freethreaded Python although many are useful generally. Most significant is cython.critical_section which provides a convenient syntax around Python's internal Py_BEGIN/END_CRITICAL_SECTION – essentially a very localized Interpreter Lock around a single object. I will compare the differences and similarities to the Global Interpreter Lock (GIL) of regular Python since understanding this is necessary to write code that works well in both.
Finally, I’ll discuss Cython’s typical attitude towards thread-safety in the freethreaded build (together will some illustrative examples from the Cython internals), and what that means for writing your own performant and thread-safe
Apache Arrow was designed with multiple goals in mind, one of the most important being the ability to exchange data between systems efficiently. In this talk we will explore what that really means and what has been the evolution of the Arrow project around the data exchange area during the years.
We will cover how to share Arrow data in process leveraging the use of the C Data interface, C Device Interface and C Stream Interface along with the Arrow PyCapsule Interface. We will show examples on how popular dataframe libraries (pandas, polars) use those exchange methods.
We will also cover an overview of the Inter Process Communication Protocol used to share Arrow data between processes and how to build your own network exchange leveraging the use of the Arrow format with Flight RPC. These overviews will be accompanied by Python examples.
By the end of the session, attendees will have a clear understanding of how pyarrow can be utilized to exchange data faster within and between their data applications. We will provide examples on how and will share our tips on when to use them.
CPython (the reference implementation of Python) comes with two types of interpreters. One interpreter is based on the traditional switch-case in C, while the other one uses a fancy feature called computed gotos. In this talk, I'll cover how I am implementing a new type of interpreter for CPython --- one based on tail calls. Preliminary benchmarks for this new interpreter suggest up to a 7% performance improvement on Python-heavy programs, with significantly better external debugging experience. This interpreter is already a part of Python 3.14.
Apache Iceberg is a high-performance open format for huge analytic tables. It brings the reliability and simplicity of SQL tables to big data. Originally built by Netflix to handle datasets at the petabyte scale, Iceberg is becoming the de facto open standard for storing tabular datasets. Its adoption can be seen across the industry, from Databricks' acquisition of Tabular to the release of Snowflake's Iceberg Tables or Amazon's S3 Tables.
In this talk, we start by looking at Iceberg's storage model and how it enables reliable concurrent data operations on top of Parquet files. We continue with Dask's DataFrame API, which allows users to scale Pandas workloads to clusters of machines in a pure Python environment. We discuss how it integrates with Apache Iceberg for ACID capabilities and high-performing querying. Equipped with this understanding, we investigate more advanced Iceberg features like hidden partitioning or time travel. Throughout the talk, we compare Dask workloads executed on Iceberg datasets against plain Parquet to gain a practical understanding of Iceberg's benefits.
4% of newborns carry a genetic disease. The use of preimplantation and prenatal diagnostic methods is essential to know how to manage and control these pregnancies. This is possible today thanks to the rise of genetic sequencing technologies, but their output is not so easy to manage. Here is where the use of programming can help us, automating and facilitating the whole analysis process. That is exactly what we will do in this talk: using Python to elucidate, as an example, the presence of mutations associated with epidermolysis bullosa (also known as 'butterfly skin') in the DNA of an embryo or fetus from a sample of the pregnant person. We will also review essential issues of regulation and quality control of these clinical tools, as well as other health applications and responsibilities associated with these technologies (so as not to fall, for example, into eugenics).
In 2006, Tom Murphy started a project of running every street in Pittsburgh (over 1,500 miles in total). He finished the project in 2022, covering 3661 miles in 269 runs. In this talk, we'll look at how we can do the same in our cities and track our progress, with Paris as an example.
We'll explore how to extract street networks from OpenStreetMap, process GPS tracking data from running activities, and build a system to track progress toward covering every street in a city. We'll dive into challenges like handling GPS inaccuracies, matching runs to streets, and maintaining a database of covered streets.
This talk is aimed at Python developers interested in working with geospatial data using Python libraries like osmnx, shapely, geopandas, and storing it for efficient querying in Postgres and PostGIS.
You have written plenty of tests. Your test code is well-organized, runs regularly, and the reporting is top-notch. But how do you know that your tests are doing their job and finding bugs before your users do? In this talk, we will have a look at test quality in Python projects. What are good tests for Python codebases? Where should we focus our testing effort? How do we make our tests maintainable? What role should coverage play in looking at a test codebase? Can code mutation help us gain insight into the quality of our test base? After many years of Python and software quality work, I want to give you some additional ideas about good tests in Python that you can hopefully apply to your own tests.
Networks are all around us, shaping phenomena like epidemics, communication, and transportation. In this talk, we will explore how real-world problems can be analyzed and solved using graph-based methods and simple algorithms. Drawing from examples such as trade networks, corporate structures, and historical data, I will demonstrate how network analysis reveals insights that would otherwise remain hidden.
Using NetworKit (and NetworkX), we will analyze real-world datasets to answer questions like:
1. What does the core-periphery model reveal about trade networks?
2. Can we rank painters by skill using network models?
3. How do corporate hierarchies differ from interaction hierarchies within organizations?
Throughout the talk, I will introduce key concepts in network analysis and showcase Python as a tool for research. Attendees will have access to all datasets and code, enabling them to replicate the analyses and apply these techniques to their own projects. This session is designed for Python enthusiasts with an interest in data science, networks, and/or applied research.
API versioning is tough, really tough. People only talk about how to structure it in terms of API design but how do you actually implement it? We tried multiple approaches to versioning in production and eventually ended up with a solution we love. During this talk you will look into the tradeoffs of the most popular ways to do API versioning, and I will recommend which ones are fit for which products and companies. I will also present my framework, Cadwyn, that allows you to support hundreds of API versions with ease -- based on FastAPI and inspired by Stripe's approach to API versioning.
After this session, you will understand which approach to pick for your company to make your versioning cost effective and maintainable without investing too much into it.
We’re all familiar with pytest fixtures. They’re invaluable for setting up environments before each test run, tearing them down afterward, and providing essential data for test execution. They introduce modularity and reusability to tests, ensuring consistency across multiple runs. Similarly, pytest’s parametrize annotation allows us to run the same tests with various input permutations and combinations. Together, fixtures and parametrize form a powerful toolkit for creating clean, maintainable, and scalable test suites.
Now, let’s consider a common engineering scenario: migrating from an old API to a new one. The outputs of the two APIs remain the same, but the inputs differ. Tasks like refactoring and deprecating older APIs are part and parcel of every engineer’s job. So, how can we make this migration easier?
While core business logic often needs thoughtful redesign, our focus here is on tests, particularly unit tests. Pytest parametrize can help us run tests with different inputs, while fixtures simplify setup and teardown. But what if we could go a step further? Instead of writing entirely new tests for the new API, what if we could reuse existing tests?
In this talk, I’ll demonstrate how to enhance test reusability, simplify test management, and streamline test cleanup by passing pytest fixtures as parameters to existing tests and seamlessly upgrading existing tests to cover workflows and scenarios for both old and new APIs. Attendees will learn to write more efficient and elegant tests by leveraging the power of pytest!
Medical coding is essential for healthcare systems, yet it’s often slow and error-prone due to the complexity of translating clinical notes into standardized codes. This challenge is exacerbated by varying coding guidelines, medical jargon, and frequent changes in standards. In this talk, we’ll explore how AI, powered by Python, is transforming medical coding to improve speed and accuracy.
We'll cover Python techniques and libraries - such as LangChain, Transformers, and FastAPI - used to automate the process. You’ll learn about available open-source datasets, pre-trained models, and the role of data annotation in automating medical coding tasks. We’ll also explore whether a purely generative AI approach is sufficient, or if hybrid methods combining traditional coding with AI are more effective. By the end, you’ll understand how Python and AI are improving healthcare workflows, and where the future of AI in medical coding is headed.
GetYourGuide is a global online marketplace that helps travelers discover and book the best experiences. One of our core challenges is ensuring users always see the most relevant activities first—a task historically powered by an XGBoost-based ranking system. However, as we continued refining our tree-based models, returns on incremental improvements began to plateau. To achieve a significant performance boost, we decided to adopt Deep Learning for its flexibility to create customized networks and ability to capture complex patterns and interactions within the data that traditional models could not.
In this talk, we will share how, in just nine months, we migrated our ranking pipeline to a Deep Learning architecture while maintaining tight latency and high-throughput requirements. We will walk through our phased approach, starting with a minimal viable model to confirm our production setup and gradually increasing its complexity. Along the way, we tested over 50 iterations offline and ran more than 10 live A/B tests to validate the impact on our customers. Ultimately, we rolled out a PyTorch transformer-based model with significant business impact. We will also discuss the main challenges we faced on the operational and modeling sides, how we overcame them, and the lessons we learned.
You will leave with practical strategies for transitioning from traditional tree-based models to neural networks in production. Join us to learn how to advance your machine-learning capabilities and unlock new dimensions of relevance and personalization for real-time ranking.
After making a splash with major performance improvements in Python 3.11, things were relatively quiet for 3.12 and 3.13. CPython got faster, but not by much.
For 3.14, performance is up again. CPython 3.14 will be quite a bit faster than 3.13 and, we hope, 3.15 will be quite a bit faster again.
In this talk, I will cover the most important ways in which we are speeding up CPython 3.14 and plan to speed up 3.15, including:
* A faster interpreter
* The JIT compiler
* Faster garbage collection
* Lower overhead reference counting
* Tagged integers
Have you ever wanted to process big geospatial data from OpenStreetMap or Overture Maps Foundation? What if I told you that you don't need an entire technology stack to retrieve data the size of a country and wait an eternity to process it.
With QuackOSM and OvertureMaestro, you can easily work with whole-country vector and tags data without installing any additional dependencies - come and find out how you can use it in your next project!
QuackOSM is a powerful and user-friendly library that streamlines the process of accessing and manipulating OpenStreetMap (OSM) vector and tags data. It's using the DuckDB engine with its Spatial extension, and PyArrow library that enables users to efficiently retrieve large-scale OSM data in the GeoParquet format.
It's similar in functionality to other available libraries, but it's faster, can work with bigger than memory datasets and doesn't require any additional dependencies.
OvertureMaestro is a twin library for accessing Overture Maps data using a very similar API and, in addition, using multi-processing and a special index to reduce the amount of data needed for retrieval.
In addition to the API, the libraries also include a CLI allowing them to be used in data engineering tasks, for example when loading data into cloud databases.
This talk will dive deep into the inner workings of the QuackOSM and OvertureMaestro libraries. The talk will also cover how DuckDB and PyArrow work with the GeoParquet file format.
Breaking HTTP Boundaries: ASGI to build your fleet management system in Python
ASGI (the Asynchronous Server Gateway Interface) is a spiritual successor to WSGI, providing a standard interface between async-capable Python network protocol servers, frameworks, and applications. While ASGI is primarily known for web applications, its powerful interface extends beyond HTTP and WebSockets. This talk demonstrates how to leverage ASGI concepts to build a custom protocol server of your choice.
We'll explore the ASGI specification in detail and learn how to apply it to custom application layer protocols through the lens of a fleet management system built from scratch.
We'll dive deep into:
- Core concepts of the ASGI specification and its protocol-agnostic design principles
- Understanding the distinction between protocol servers and applications
- A practical demonstration showcasing ASGI's flexibility and features through a fleet management system example. We'll explore two different ASGI applications within one system: an ASGI application that collects vehicle data over a telematics TCP protocol and an ASGI web server that serves this data through a Python-built UI.
By the end of this talk, you'll discover that ASGI isn't just limited to web apps - it's a powerful tool that enables you to create any network protocol server in Python while maintaining asynchronous performance and efficiency.
Large Language Models (LLMs) have become transformative tools, reshaping industries and research alike. Yet, while their outputs can feel like magic, their inner workings remain opaque to most users. How do these models "think"? Can we untangle the layers of their reasoning processes? Step into the cutting-edge field of Mechanistic Interpretability, where we aim to decode the black box of LLMs into understandable, human-readable components.
In this session, we will explore how researchers and practitioners dissect neural networks, uncovering the mechanisms behind their behavior. We will start with the foundational concepts, what Mechanistic Interpretability is and why it matters, before diving into practical tools and techniques.
We will emphasize why this field is essential: from ensuring models behave safely and ethically to optimizing their performance and fostering trust in AI systems. Attendees will leave with a conceptual toolkit for interpreting LLMs and practical takeaways on how to start applying these insights in their own work using Python libraries like PyTorch, Transformers, and interpretability-specific tools.
This talk assumes familiarity with AI fundamentals but introduces advanced concepts with approachable explanations. Whether you're a researcher, developer, or curious enthusiast, you’ll gain actionable insights and inspiration to engage with one of the most exciting frontiers in AI. No specialized hardware or prerequisites are required, just bring your curiosity!
Infectious diseases are the third leading cause of death worldwide, claiming more than 13 million lives every year. While there are many interventions available for managing epidemics (like vaccination, testing and treatments), the best approach is not always clear. There are complex dynamics at play, and the optimal response may vary significantly depending on outbreak severity, funding available, and even sociopolitical context.
Computational modelling is a powerful tool for evaluating the potential impact of different public health approaches, but the difficulty of building fit-for-purpose epidemiological models from scratch is a barrier to widespread use.
Atomica, an open source Python-based simulation engine, aims to make this kind of modelling more accessible. It provides an easy-to-use yet highly configurable way to build disease models, with built-in support for public health interventions and optimisation with budget constraints. By leveraging population, transmission, and intervention data, as well as conceptual knowledge of how people progress through stages of disease, this package allows us to forecast the potential consequences of public health strategies in specific countries or settings. With this insight, we can help governments and health organisations to make the best possible decisions on what to prioritise, saving many lives in the process.
Whether you’re a beginner or an expert Pythonista, this talk will equip you with the tools to simulate a real-world typhoid epidemic and optimise funding distribution for maximum impact.
Python is everywhere—except, it seems, in public health. As a global health practitioner working across continents, I have used Python behind the scenes to influence policy, support technical decisions, and uncover hidden patterns in health data. This talk will present rapid case studies of Python’s role in public health decision-making, from the Pacific Islands to China, from the Philippines to Europe.
- We will explore a network analysis of a social media debate on vaping that unexpectedly intersected with regional politics.
- We will examine visualisations of heart disease and stroke mortality that reframed health improvement strategies.
- We will explore a data pipeline on women's health that created the graphic backbone of a European report on the subject.
- We will look at a gamification of chronic disease progress in Europe that informed the European Programme of Work on United Action for Health 2026–2030.
Each of these examples demonstrates the power of Python’s ecosystem—not just for data science but for influencing real-world health policy.
Despite its versatility, Python remains underutilised in public health. Why does this gap exist? How can we bridge the divide between Python as a tool for developers and its potential as an engine for “hacking health”? This talk will close with a Call for Health, inviting collaboration on ways to make Python a more prominent force for population health.
As our Python codebases grow larger, so do our test suites tend to extend. This usually results in a significant increase in the time that our different tests (unit, integration, end-to-end, etc.) need to complete.
Long-running tests can negatively affect the development process in multiple ways, for example:
- Slower development (Definition of Done should include proper testing), hurting the sense of productivity
- Slower and less code-feedback cycles (code reviews)
- It can take more time to bring a hotfix out to production
- Additional budget being spent on CI/CD pipelines
This talk aims to point out methods that can help you immediately address a slow test suite, as well as ways to structure your set of tests later on, to improve even more.
We will discuss how to handle these problems after they are detected. In general, it is important to first measure and pinpoint possible bottlenecks before proceeding to any improvements. As they say, “Premature optimization is the root of all evil.”...
The methods will be presented starting from the simplest to apply, up to the more niche gotchas that I have gathered throughout my journey as a Python developer. Each method will be accompanied by a simple example, that will also be available on GitHub for the attendants.
We will mainly be using pytest as our test runner, being one of the most popular ones, and also providing quite a useful toolset. To name a few of the techniques that we will go over:
- Distributed CPU testing
- Parallel testing
- Fixture lifecycle evaluation
- Package caching
- Separating what to test from how to test it (choosing the right abstractions)
In conclusion, after completing the talk you should have found out ways to improve the time your tests need to complete, that you can apply already from the next day, but also how to structure your tests in the future to ensure better outcomes.
We know that Free Threading will take a long expecting, so why not begin preparing by exploring and utilising subinterpreters while we wait? Perhaps they could even fill the gap you believe NoGIL will fill when it eventually arrives.
Lately, PEP 703, PEP 554, PEP 734, and other related proposals have been getting more attention than ever. The growing interest in parallelism in Python is exciting, but it’s crucial to take a step-by-step approach and stay grounded.
To make informed decisions about parallelism in Python, it’s essential to understand the available options—not just as a stopgap while waiting for Free Threading, but as real solutions to different problems.
In this talk, we’ll dive deep into subinterpreters, not merely as an alternative to Free Threading but as powerful tools in their own right. We’ll explore their internal workings, when and how to use them effectively and walk through real-world, practical examples. Additionally, we’ll discuss their short and mid-term future in Python’s ecosystem.
To get the most out of this session, you should be familiar with the differences between concurrency and parallelism and understand the GIL and why it poses challenges in specific scenarios.
Global climate models provide crucial insights but lack local precision, limiting their practical application for regional planning and adaptation strategies. This poster presents a Python-based framework for climate model downscaling, using deep learning to bridge the gap between global and local predictions.
The approach leverages PyTorch's neural network capabilities and Python's scientific computing stack for processing complex climate data. The framework combines xarray for multi-dimensional data handling, dask for distributed computing, and custom PyTorch layers optimized for atmospheric pattern recognition. Through MLflow's experiment tracking and Panel's interactive visualizations, we will demonstrate how different neural architectures affect prediction accuracy across various regions and climate variables. This downscaling approach significantly improves prediction accuracy, reducing the Root Mean Square Error (RMSE) by 40-65% compared to traditional statistical methods, with correlation coefficients (r²) improving significantly for temperature predictions in complex terrain regions.
By integrating domain-specific libraries like metpy with NumPy's computational abilities, we will showcase how Python enables scalable climate science . We will be showcasing live notebooks showing how machine learning improves climate predictions. The implementation demonstrates how Python makes it possible to process large amounts of climate data efficiently and create accurate local forecasts.
Culture defines us, and preserving it is essential for maintaining our identity and heritage. While recent advancements in AI have focused on digitizing African languages, cultural preservation extends beyond language to include traditional games, many of which face extinction due to the rise of video games. This project takes a step toward preserving African culture by digitizing Ayo, a traditional Nigerian mancala game.
Using Python, with NumPy and PyTorch for algorithm development and Tkinter and FastAPI for the graphical interface and backend, this research implements reinforcement learning (RL) agents capable of mastering Ayo. Three agent types—Heuristic, Minimax, and Pruned Minimax—were trained, with the Pruned Minimax agent demonstrating exceptional performance. It not only outperformed other agents in simulations but also defeated every human player tested so far.
This ongoing work bridges AI and cultural heritage, showcasing Python's versatility in addressing real-world challenges. By digitizing traditional games, we ensure they remain accessible and relevant for future generations. Attendees will gain insights into the technical implementation of reinforcement learning for game AI, explore the challenges of adapting AI to traditional games, and witness a live demonstration of the Ayo game interface. This project serves as a blueprint for preserving and promoting cultural heritage globally, demonstrating the power of Python in advancing AI research and cultural preservation.
Stress has become a major issue for human beings and especially students, impacting both their general well-being and academic performance. Over the years, studies have revealed that academic stress and other stressors, such as time management, impede the smooth going of students in achieving their optimal academic performance and well-being. The work is aimed at using machine learning techniques to map and predict students’ stress levels using a psychological evaluation model. Data were collected from students of McPherson University using both the Perceived Stress Scale (PSS-10) and the 50-item International Personality Item Pool (IPIP) questionnaire. The data collected were preprocessed and trained by a variety of machine learning techniques to develop a psychological assessment model. Nine machine learning algorithms, which include Naive Bayes, Random Forest, Decision Tree, Logistic Regression, Linear Discriminant Analysis, Multilayer Perception, Bagging, Support Vector Machine (SVM), and K-Nearest Neighbour, were evaluated to determine the best for the model. Performance evaluation of the developed model is done using precision, recall, F1 score, and accuracy as metrics. The result shows that Random Forest is the best-performing classifier in this study, though with a low percentage due to the presence of imbalances in the data and feature selection.
Jupyter Notebooks are awesome. They've made interactive coding and data exploration super accessible for a whole generation of data scientists and engineers. But there are also some clear hindrances with the classical notebook—like hidden states that can lead to inconsistencies, difficulties in structuring code for production, and collaboration challenges.
Join me as we explore Marimo, an open-source reactive notebook alternative that's reproducible, git-friendly, executable as a script, and shareable as an app.
We'll explore Marimo's capabilities by solving a real-world machine learning problem. Which means, we'll go through the full lifecycle of tackling such a problem; from data analysis and creating visualizations to building an interactive dashboard and deploying a simple machine learning model. We'll also discuss its limitations, make a comparison with popular alternatives, and have a peek at their future roadmap.
Ever tried using “one data model to rule them all” and ended up with a tangle of constraints, endpoints, and SQL tables? You’re not alone! In this talk, we’ll explore the lofty dream of unifying your Pydantic models across constrained LLM generation, FastAPI inputs/outputs, and SQLModel ORM definitions. But, is it possible to keep a single source of truth without driving yourself (and your teammates) nuts? Or should you split them up and keep everyone happy? We’ll tackle practical examples, including the joys (and pains) (mostly pains) of juggling Pydantic v1 vs. v2. You’ll leave with a clear framework for deciding how best to structure your models and a road map for staying sane when you want Pydantic for all the things.
In this talk, we will explore how Python can be leveraged to analyze and visualize football data for the Germany national football team, managed by Julian Nagelsmann, on their journey to winning the 2026 FIFA World Cup. We will dive into the fascinating world of football analytics, showcasing how to collect and process match data (e.g., Hudl Statsbomb, Sportmonks, and Understat), including player tracking, event logs, and tactical formations. We'll discover match data to demonstrate how the team's performance reflects Nagelsmann's tactical principles, such as gegenpressing, offensive play, and compactness. Join us to unlock the power of Python in football analytics!
In a nutshell:
Snapshot testing simplifies testing large result sets, reducing manual work, especially for APIs and for data processing. I'll show you how to use it in your projects.
This talk is about:
* Snapshot testing: Usage and evolution.
* The inline-snapshot library, by Frank Hoffmann, the pytest plugin you were missing
* Main use cases
* Tests that are deterministic but have large outputs that are hard to write by hand.
* Refactor or approval testing: you need tests to ensure a function's result stays consistent during refactoring.
* Real-life examples with black+flake8 and ruff
* Examples with dirty-equals
* What is a meaningful diff or tricky bits of formatting and linting
* Handling different outputs depending on library versions
Relevant for you if:
* You test functions returning large outputs, like dicts or dataframes
* You deal with the main fields of usage: data processing, data pipelining, APIs
Main takeaways:
* General knowledge about snapshot testing
* Specific knowledge about the inline-snapshot library
* Real world use-cases of inline-snapshot: where to start, what to use it for, where it will boost your productivity
To cite Samuel Colvin, creator and founder of Pydantic, “inline-snapshots is transformative to how we write unit tests in Python! If you're using pytest, and you're not using inline-snapshots, you're wasting your time; simple as that.”
Requirements:
A general idea about tests and different kinds of tests.
Documentation is an important part of each project, but it does not mean that it’s always up-to-date. Updating documentation continuously is quite a lot of work and not every project has a capacity to invest so much time into it, especially when a project is on a tight release schedule.
This talk will show you the basics of a good documentation and you will learn about different types of documentation, how to use and when to write them.
Anastasiia will also share her experience on how to introduce documentation as a part of your team’s daily routine and update it continuously.
From this talk you will learn:
- how to start with documentation for your code,
- how to make your documentation to update continuously,
- running Python code inside of your documentation with PyScript,
- documentation best practices.
After this talk you will be able to check out my repo with a few samples of different types of documentation as a part of continuous documentation for a dummy piece of code.
Often our UI tests are failing because they are flaky and slow, or because the underlying server is slow. That makes the test suite very unstable, and makes it harder to find real issues. In an Open Source world this problem is even worse when your tests run as part of a gating job, because it blocks patches from being merged. In this talk we will explore a few techniques that make our test suite more stable and faster, together with specific code examples using PyTest and Selenium.
Attendees will get a chance to learn about:
1. The difference between unit tests and integration tests.
2. Using API calls to perform test setup and verification.
3. Limiting the scope of a test by Pytest mocking.
4. Advanced features like dependency injection and parametrization.
This session is ideal for anyone who needs to make their user interface test suite more stable or wants to get started writing tests for their web application.
“MIDI, those cheesy sounds from the 90s?" is an actual question some guy asked me at an AI conference one day. What an inspiring question! This talk flips the outdated view of MIDI as retro noise, showcasing it as a powerful format for representing and analyzing music. While some think it’s obsolete, MIDI remains the backbone of modern music production and a very active research topic in machine learning. This talk unpacks MIDI’s structure and demonstrates how Python libraries like mido, pretty_midi, and MidiTok turn it into a tool for research and creativity. From visualization to music generation, practical examples reveal the modern applications of symbolic music.
The takeaway? Python makes it easier than ever to explore MIDI’s potential and apply it to a wide range of musical and analytical tasks.
In disaster scenarios, reliable communication is crucial. A solution for offline disaster relief coordination is presented, using OpenStreetMap vector maps hosted with FastAPI on a Raspberry Pi, which provides a WiFi hotspot. Street and location names are extracted from OpenStreetMap data to enable location searches. The system can be extended by using a LORAWAN gateway to receive data from water level sensors or positional information from disaster relief workers.
All the knowledge required to host such a map server will be provided.
From predicting weather and modeling fluids to optimizing financial markets, traditional simulations rely on solving partial differential equations (PDEs) or using data-driven machine-learning models. However, PDE solvers are often computationally expensive, and pure data-driven approaches struggle with limited or noisy data. Physics-Informed Machine Learning (PI-ML) offers a powerful alternative by embedding physics directly into deep learning models—combining the strengths of both worlds.
This talk will introduce Physics-Informed Neural Networks (PINNs) and extend beyond them to more advanced approaches like Neural Operators. We’ll explore how these techniques are transforming real-world applications—from fluid simulations in engineering to climate forecasting and even economic modeling.
Attendees will learn:
✔ How physics can enhance ML models for better generalization and efficiency.
✔ Practical implementation using Python frameworks like PyTorch, Deep-XDE, and NVIDIA Modulus.
✔ Case studies where PI-ML models outperform traditional methods.
No deep math or PDE knowledge is required—this session is designed to be insightful, engaging, and accessible to ML practitioners, engineers, and researchers curious about bridging physics and AI.
PyPI (Python Packaging Index) is used by over 800,000 users. With its ever growing user base and popularity, comes the need for making sure the PyPI ecosystem is secure for all users all without constraining ease of use. Part pep talk (pun intended!), part presentation, this talk plans to discuss some of the challenges that were tackled in terms of bringing the various PyPI support backlogs current in both account recovery and PEP 541 as well as other support requests. This talk will also discuss process improvements made, lessons learned, and what’s in store in the future for PyPI support.
In 2020, I built my first side project. I "scratched my own itch" and started selling it, and since then, the project has earned me over $15,000. However, just a few months after its release, I was so overwhelmed by maintenance work that I considered shutting it down. Instead of killing the goose that lays (small) golden eggs, I decided to automate the project.
In this presentation, I will share how I used the fair-code licensed tool n8n to automate interactions with users. By connecting custom Python scripts, a web scraper, and integrating a Telegram bot, I created a system for fast and easy interactions with my project.
I'll also discuss the highs and lows of building a side project. As a software developer, I always saw a project with recurring revenue as the "holy grail." After putting in the initial effort to build and launch it, I thought I could sit back and watch the money roll in. Not quite. Building the project is just the beginning—you'll also need to handle customers, combat fraud, and manage the challenges that can quickly lead to burnout.
This talk is 34% about Python, 33% about lessons learned (the hard way) about having a side project with paying customers, and 33% about setting up free tools to automate things.
The Python Software Foundation (PSF) keeps the wheels turning for the Python ecosystem–but how? With a small but dedicated staff, the PSF’s infrastructure supports billions of requests per month and delivers petabytes of bandwidth. From major services like PyPI, to seasonal spikes like PyCon.org, and even lesser-known essentials like mail hosting, buildbots, and vote counting, the PSF’s infrastructure is a vital yet often invisible backbone of the Python community.
In this talk, we’ll dive into the details of what exactly the PSF does, the infrastructure behind Python, the critical roles played by key partners like Fastly and GitHub, and how you can help sustain (and even improve) it.
Testing is a cornerstone of software development, but many teams struggle with end-to-end (E2E) testing due to its complexity, inconsistent results, and maintenance overhead.
While unit testing has become the default choice due to its simplicity, it often fails to catch integration issues that only surface in real-world scenarios. This talk challenges the notion that E2E testing must be difficult by introducing the powerful combination of Testcontainers and Playwright. We'll demonstrate how Testcontainers brings unit test-like simplicity to integration testing, while using Playwright to enable writing tests that represent actual usage of the system through a developer-friendly API.
Attendees will learn how to leverage a combination of Testcontainers and Playwright to create stable test environments, understand best practices for container-based and browser testing, and walk away with practical knowledge on how to improve their testing strategies. Whether you're a testing enthusiast or just getting started with testing in Python, this session will equip you with tools and techniques to make E2E testing as approachable as writing simple unit tests.
This is a placeholder for the abstract of the current keynote.
The content of this keynote will be provided in the following weeks.
In the meantime, don't forget to subscribe to our Newsletter https://blog.europython.eu/ and remember you can get your tickets https://ep2025.europython.eu/tickets/
Enjoy Thursday's lightning talks! Short talks about everything by everyone.
Lightning talks are 5 minute talks that anyone participating at the conference can submit.
If that talk gets selected, you will have the chance to jump into the main stage and show us your project, your ideas, something you have learned, something you are proud of that's helping and contributing to our conference and community, or something else!
Be aware: there is a hard-limit on the 5 minutes, you cannot go over, because the host and audience will interrupt you.
Welcome to EuroPython 2025! Please notice the registration will happen on the Forum Hall Foyer on the 1st Floor.
You can pick up your badges at any time during the week as long as we are open!
If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!
Welcome to the third day of conference!
Yesterday was an amazing day, but for sure you don't remember all the things that were mentioned during the opening.
Join us to get an update and few more announcements. Come by and find out what is going to happen today.
This is a placeholder for the abstract of the current keynote.
The content of this keynote will be provided in the following weeks.
In the meantime, don't forget to subscribe to our Newsletter https://blog.europython.eu/ and remember you can get your tickets https://ep2025.europython.eu/tickets/
Asynchronous programming in Python has become an essential tool for developers building high-performance applications. But for many, terms like async, await, and the event loop seem daunting. This session provides a clear and concise introduction to async Python, breaking down the core concepts and showcasing practical examples of when and how to use it.
We’ll start with a simple explanation of Python’s async ecosystem (asyncio and beyond), discuss common patterns like asyncio.gather and task coordination, and demonstrate real-world use cases, such as making concurrent API calls or handling database queries through step-by-step coding.
As a cherry on top, we’ll briefly introduce Asyncer, a modern library that simplifies async workflows, for those ready to take async to the next level. By the end, you’ll feel confident to dive into async programming and leverage it effectively in your projects.
Whether you're a beginner or someone looking to solidify your async knowledge, this talk will leave you feeling empowered to tackle async Python without headaches.
Indico is a powerful open-source event management toolkit, created at the European Organization for Nuclear Research (CERN), that has been evolving over the last 20+ years. Indico has been used to host major conferences, including EuroPython itself in 2006 and 2007, as well as thousands of events at CERN, and other major international organizations/institutions alike.
Maintaining an ever-evolving project comes with unique challenges: dealing with legacy code, adopting new technologies, and managing technical debt without disrupting a large and continuously growing user base.
This talk explores the project’s technical evolution as well as focusing on how it stayed current with emerging technologies; starting as a PHP/MySQL app, it transitioned to mod_python with ZODB, briefly used a custom WSGI implementation, and ultimately became a modern Flask/Postgres/React application - sometimes integrating multiple technologies simultaneously.
By the end of this talk, attendees will:
* Understand the challenges of maintaining a long-lived web application.
* Learn strategies for dealing with technical debt while keeping systems evolving.
* Gain insights into real-world architectural decisions for open-source projects.
Join us, as two team members discuss how to stay sane with the meticulous balancing act of dealing with both technical debt and integrating new technologies/features.
This session is an overall spanning overview around the concept of time, in the context of programming.
I will enlighten you about the many pitfalls and general problems that we face when programming with relation to time.
Anyone who gives some thoughts about time may come to the initial conclusion that it's natural and easy to program with time in mind. But once you start digging into it - one might face many uncertain bumps in the roads and countless bugs with unnecessary unforeseen consequences.
We will talk about:
- Common misconceptions about time.
- Why and what we use time for in programming.
- Serialisation and representation of time.
- Best practices when communication about time. (OpenAPI specifications)
- The gist of Timezones and Daylight Savings.
- Special Relativity, and how time is about to get even weirder.
- What I would consider some best practices when coding time in python.
I hope that my talk will inspire and be a peek into the Pandora's box which is time - only we, together, can save the world from more time related bugs. Equipped with gained knowledge, I hope that you too will help even more people understand that everything is not always as simple as one would assume.
Join my presentation, as this time,
It's All About Time.
Sometimes the code that you use works, but is too slow. Yet, the source of the problem is not clear.
In this talk, you’ll learn how we identified performance bottlenecks in our shape-handling code and applied various techniques to accelerate it. We’ll walk through the entire process: reducing algorithm complexity, leveraging Numba’s JIT compiler, building compiled prototypes in Cython and C++, and ultimately implementing a Rust-based solution
Along the way, we'll discuss the unique challenges of optimizing performance for interactive applications, focusing on how we reduced latency in the napari GUI.
Topics covered:
Identifying performance bottlenecks (profiling techniques, real-world case study)
Optimizing Python code (NumPy considerations, algorithm improvements)
Just-in-time compilation (Numba’s strengths and weaknesses)
When and how to use compiled extensions (Cython, C++, Rust)
Challenges of optimizing interactive applications (napari GUI case study)
"This talk is aimed at Python developers who want to optimize numerical code, whether for scientific computing, interactive applications, or general performance improvements."
As data analysts and scientists, we often find ourselves working with large datasets, trying to extract In this talk, we'll explore the powerful trilogy of Python, SQLAlchemy, and SQL, and demonstrate how these tools can streamline your data analysis workflow. We'll introduce the basics of SQLAlchemy, the popular Python SQL toolkit, and show how it can be used to interact with a variety of databases.
Through real-world examples, we'll dive deeper into the world of SQL, exploring advanced querying techniques and best practices for database design. You'll learn how to write efficient SQL queries, optimize database performance, and leverage SQLAlchemy's features to simplify your database interactions.
By the end of this talk, you'll have a deeper understanding of how Python, SQLAlchemy, and SQL can be used together to supercharge your data analysis workflow. Whether you're a seasoned data scientist or just starting, this talk will provide you with practical tips and techniques to take your data analysis skills to the next level.
Rewriting interpreted language code with a compiled language version will end up in incredible
performance improvement, but is that enough? For many people it is, but for others, and probably
you, that's not a good reason to change your tech stack and paradigm.
With the latest developments and adoption of Rust extension in the Python world, might makes you
wonder: is this it? The answer is "Now yes, but in the future probably no".
Adding more languages to our ecosystem is a very good strategy to keep Python relevant, but at the
same time we need to remember that playing that game will make us evolve and adapt.
In this talk, you will discover some of the base reasoning of the success of Rust in the Python
ecosystem compared to C, but at the same time you will explore other languages that brings different
improvements like Zig, modern C++, and also experimental languages like Circle and Carbon.
By the creation of extensions with different languages, you will be able to judge which option is
the one that fit your needs, and that you believe can play an important role in the future of the
language.
A basic understanding of Python extensions is required in order to fully grasp the content
of the talk, but beginners will be able to follow the main idea of the presentation.
Load balancers are widespread nowadays because most software systems are web centric and service oriented. However, they’re extremely complex to build, because they must be very performant and use sophisticated algorithms to route traffic. Until recently, you couldn’t use Python to build one, because even though it would make the code simpler, the GIL prevented multiple threads from executing Python at the same time.
Now that you can, what are the practical implications in your day to day work?
In this talk, we’re going to live code a load balancer in Python. This will help us understand the pros and cons of using modules such as asyncio, threading and concurrent.futures, and what changes when we remove the GIL from the way.
Whether you’re building systems that demand concurrency (such as AI models or DevOps pipelines), or you’re just curious about how tools like gUnicorn or Starlette work under the hood, you’ll come away with practical insights on how to start off the NoGIL era on the right foot.
Let’s face it, data debt is real, and it is killing your productivity!
Every hacky pipeline, missing contract, and “we’ll fix it later” adds to your data debt — and like tech debt, the interest is brutal. Broken dashboards, skyrocketing costs, and late-night firefighting are holding your team and data back from scaling and delivering value.
In this session, we’ll dive into real-world governance strategies like data contracts, semantic layers, and treating data as a product, showing how they can help cut costs, boost quality, and get ahead of your data problems.
What you’ll learn:
- How to stop data chaos at the source instead of endlessly cleaning up
- Why data contracts and semantic layers are your best friends
- How small governance tweaks can cut costs and improve data quality
- How to make data governance practical for engineers
Packed with hands-on strategies, this session will help you build smarter — not firefight.
We all know that caching speeds up database queries, but are we aware which caching technique is right for our specific use case? Did we know that even simple, seemingly obvious code can be drastically improved with the right caching strategy? Improper or excessive use of caching can however introduce unnecessary complexity—impacting deployment, performance, scalability, and maintenance.
In this talk, we will address these challenges by exploring Python-specific caching strategies and the decision-making process behind transitioning from local in-memory caching to external solutions. We will focus on optimizing applications without over-complicating things.
Starting with a quick introduction on caching fundamentals, we will dive into simple Pythonic ways to leverage local in-memory caching with functools.lru_cache, cachetools, and joblib, and explore how cache warming, expiry, and cache invalidation can really improve performance. After comparing multiple caching strategies, we will discuss external caching and when it’s time to use it. Through a live demo, we’ll see how to set up Redis and integrate it into a Python app to scale up our caching strategy effectively.
Through this talk attendees will:
- Learn how to implement efficient internal caching using Python’s built-in libraries.
- Discover practical techniques for cache invalidation, expiry, and cache warming to ensure optimal cache performance.
- Understand when to scale with Redis (or other external caching solutions) and how to integrate them into Python projects.
- Be equipped to choose the right caching strategy for different use cases, ensuring faster and more scalable Python applications.
What database should you choose? Worse, what kind of database should you choose?
My aim is to give you enough information to make that choice, or at least be aware of what the alternatives are.
I'd argue that there are five important database types at the moment, differing in how they regard the "shape" of their data. I'll give a brief introduction to each, explaining how it works, and discuss why you might want to use that particular type of database, depending on your data and what you want to do with it. I'll show case at least one open source example of each.
I'll cover:
- Relational (PostgreSQL®, SQLite)
- Columnar (ClickHouse®)
- Document (OpenSearch®)
- Key Value (Valkey™️)
- and as an extra, Graph (Neo4J®)
Microdot is a modern asynchronous open source web framework for Python with a nice feature list including web templates, authentication, user sessions, WebSocket, Server Sent Events (SSE) and a Flask-style test client. What's interesting is that Microdot is also so small that it fits nicely on tiny microcontrollers such as the ESP32 or the Raspberry Pi Pico W, which run MicroPython instead of CPython.
I am the author of Microdot, and in this session I'd like to not only show off my little project, but also discuss how I was able to build a feature rich web framework that is "micro" enough to function on resource constrained MicroPython boards.
Starting a new Python project comes with many decisions:
- Flat layout or src layout?
- What will be the entry point of your application?
- Where will tests live?
- Packaged application or not?
- One top-level package or Django-like apps?
- Absolute imports or relative ones?
- How will the application be installed?
- Docker: for runtime, development, or both?
- How to coexist with other technologies?
There’s no single standard for a Python project structure, and popular tools offer a lot of flexibility: uv can create a library, an application, or a packaged application, pytest documents two possible test layouts and supports three import modes, and mypy implements its own import mechanism.
If you’re starting a library, you can take inspiration from open-source champions, but applications are usually proprietary. Many Cookiecutter templates exist online, but which one should you choose? A common approach is to clone an existing project your company uses, but in my experience, this isn’t always the best idea.
We’ll explore the key decisions and weigh the benefits and drawbacks of each option. I’ll point out common mistakes to avoid. My goal isn’t to sell you on my favorite directory structure. Instead, I’ll help you choose what suits your use case best, ensuring that your choices play well with each other.
This talk is intended for Django or FastAPI developers with interest on HTMX development or some experience with it.
The Python and Django community has been at the forefront of the “hypermedia revolution” being one of the early adopters of HTMX.
Although there are a lot of introductory tutorials and presentations about shifts from SPA’s to HTMX that had great success, there’s a lack of patterns and useful technical examples from real in-production applications.
This is a talk that starts by presenting why HTMX pairs so well with Django, and provides answers to many common issues and missing standards that creep along an application development using HTMX.
Based on my past experience working on multiple projects using this tech stack, I’ll share several points on how to make a Django project more focused and oriented to the hypermedia way.
This presentation covers topics such as the advantages of an HDA vs the typical SPAs, using the concept of "resources on demand" as an architecture, component driven templating, view composition and server-side state management, alongside many others that should help any Python developer to deliver fast and with great quality on the Web.
Managing how microservices communicate with each other can quickly become overwhelming in large scale systems. Specially for non-cloud antive applications that we want to migrate to Kubernetes like environments. Ensuring secure connections, balancing traffic, and tracking interactions across services is critical.
During this session, we will introduce the concept of a service mesh and explain why it’s essential for modern microservices architectures. From there, we’ll explore Istio and how it can be used with Python applications to handle these challenges seamlessly. By the end of this talk, you’ll understand how Istio can help you simplify operations, enhance security, and improve observability for Python microservices.
Whether you’re new to service meshes or looking for practical ways to adopt Istio in your Python ecosystem, this session will provide clear and actionable steps to get started.
If managing microservices feels like a continuous battle, Istio might just be the tool you need...
Pitch
Ever wanted to know how the displays in your smart watch work and how you can create such devices yourself ? Using just your Python skills and a bit of USB cabling ? MicroPython and LVGL make this easy and this talk will show you how.
Abstract
The world of embedded hardware devices is often considered difficult and having a steep learning curve. MicroPython has changed this for the better and now you no longer have to drop to C to implement your ideas on microcontrollers and dedicated hardware.
In this talk, we will explore the world of visualizing data using a nifty device based on the ESP32 microcontroller and a TFT display - better known under the name Cheap Yellow Display (CYD) - with the aim of creating a hardware conference talk timer.
The implementation is done in MicroPython and uses the high quality open source embedded graphics library LVGL, the basis of many commercial devices with displays and smart watches, for beautiful graphics.
I'll show the tooling needed to get started, useful resources, demo the application and discuss some of the pitfalls found along the way.
Resources
- MicroPython
- LVGL
- LV MicroPython
- CYD
Snakes are not wildly known to be fast animals.
In some cases though, they can be very quick and efficient.
Python is no different.
This talk is for people who are interested in making their Python code run faster.
Specifically, we will look at some features in NumPy, Numba, Cython and Rust that can be used to make your code run smoother.
The performance impact will be illustrated with live demos of the Mandelbrot set.
You will walk away with a collection of tools and libraries that can be used to increase performance in your code base.
We use assignment all the time in Python. But what really happens when we use an = in our code? The answer is: It depends. In this talk, I'll explore what happens when we assign a value to a variable, when we mutate an existing value, and when we assign to an attribute. Along the way, we'll explore variable scopes, byte codes, and descriptors. By the end of this talk, you'll appreciate all the hard work that the little = sign is doing, and the remarkable stuff that happens behind the scenes when you use it.
This talk delves into the often-overlooked world of Python bytecode, exploring its intricacies and demonstrating its uses. We'll journey from the basics of bytecode generation and disassembly to its evolution within CPython and the challenges faced by specialized tools like type checkers. Through concrete examples, including a case study of PEP 709, we'll uncover how changes in bytecode impact the wider Python ecosystem, highlighting that bytecode development is not just a technical challenge; it's deeply intertwined with open-source engagement, driven by passionate individuals, effective communication, and a shared vision. The speaker shares their insights into the decision-making processes behind language tools, with a reflection on the importance of community and collaboration in shaping the future of Python.
The Raspberry Pi Pico W, combined with MicroPython, has revolutionized accessible electronics education by creating an affordable yet powerful learning platform. This talk demonstrates how students can begin their journey into programming and electronics using just a standard PC and €10 worth of hardware. Starting with basic programming concepts, we'll explore practical projects that bridge the gap between software and hardware, showcasing how MicroPython's intuitive syntax enables both learning and real-world applications. Students progress from simple LED and button interactions to creating sophisticated projects with displays and mobile phone integration, keeping them engaged through immediately useful applications. The structured learning path covers sensor integration, wireless connectivity, and practical IoT applications, making electronics and programming education truly accessible without compromising educational depth. All project materials and source code are available on GitHub, enabling immediate implementation in educational settings.
There are many ways to fully unleash the power of GPU: using math libraries specialized for GPU scientific computing, device kernel fusion, JIT compilation, or LTO. However, until recently, only C++ developers could fully benefit from those techniques. While Python libraries like CuPy have used at least some of these features under the hood, the knobs and nuances crucial for performance tuning were not exposed to the Python community. It requires advanced users to resort to custom integration with the C and C++ stack, whenever they need fine-grain control.
The nvmath-python open-source library released last year aims to bridge this gap for core math operations. Instead of finding a trade-off between ease of use and performance, its design aims to provide both. While respecting Python principles, it offers the same flexibility and control the C++ developers have, including integration with Numba and NVIDIA runtime compiler stack: nvrtc, and nvjitlink. To seamlessly integrate into the Python ecosystem, it handles all the necessary dependencies while effortlessly interoperating with popular tensor libraries.
The library targets Python developers, scientific computing community, AI-oriented practitioners, and anyone striving for peak GPU kernel performance. nvmath-python, supporting both CPU and GPU execution space, can be easily integrated into existing workflows written in NumPy, CuPy, SciPy, scikit-learn and others. It supports GEMMs and FFTs with prolog/epilog fusion and narrow precision types, random number generation, and all other capabilities of CUDA math libraries exposed to the user.
In this talk, we would like to share the design principles behind nvmath-python and demonstrate how it can be used to accelerate scientific computing workloads in Python. We will put special emphasis on the just-released sparsity support and distributed computing capabilities.
Configuration. We all need it. We all hate it. And somehow, we all manage to screw it up at least once in every project.
Over the years, I’ve seen it all – configs manually created for each environment, dumping a bunch of values in a JSON, manually reading env variables without any type consistency, and whole pipelines failing because of a missing comma. But after a decade of suffering, I finally found the way: Pydantic settings.
With Pydantic, we get a configuration that’s:
✅ Type-safe (No more guessing if that "timeout" value is actually an integer!)
✅ Flexible (Works seamlessly across local setups, Docker, Kubernetes, and the cloud)
✅ Easy to validate (Stop your app from crashing at runtime because someone put "True" instead of True)
✅ Perfect for testing (Yes, we’re gonna talk pytest tricks too)
BUT we will not talk about basic Pydantic settings features. We will deep dive into advanced typing to create a super-strict, no-mistakes-guaranteed config that will last longer than any JavaScript framework. Not only that, you will see how to use it in your project without relying on global state, with some practical, battle-tested rules I’ve learned over the years.
By the end of this talk, you'll walk away knowing:
🎯 Why most traditional config approaches suck
🎯 How to build a rock-solid configuration setup with Pydantic
🎯 How to actually test your configs and their usage properly (so they don’t explode in production)
🎯 Some hidden Pydantic tricks you probably haven’t heard of
If you think configuration is boring, I dare you to sit through this talk and not feel at least a tiny bit excited about it. Worst case? You'll leave with fewer config-related nightmares. Best case? You'll finally have a configuration setup that just works.
P.S. These techniques go beyond configuration—you might end up using them for other parts of your project too! 🚀
CLOUD, CLOUD, CLOUD!!! Organizations today turn to cloud solutions to reduce costs, accelerate delivery, and streamline operations. Yet, the question remains: how can Python developers thrive in this age of cloud? Enter the Cloud Development Kit (CDK) for Terraform, which empowers teams to build and manage infrastructure using Python in a Pythonic way. This session explores how to apply object-oriented principles to infrastructure-as-code to create cleaner, more maintainable, and testable IaC, while seamlessly managing multiple environments. We will also discuss how leveraging reusable functions and code blocks speeds up delivery timelines and simplifies the maintenance of large-scale projects, ensuring code consistency and reducing duplication. Additionally, we’ll highlight best practices for Terraform CDK— including project organization, code reusability, version control strategies, and testing patterns—to ensure scalable deployments and streamlined cloud management. By the end, attendees will understand how Python’s familiar syntax and Terraform’s infrastructure automation can be combined to reduce operational overhead, boost developer velocity, and ensure robust cloud environments across all stages of development.
Every SaaS will come against the same issue at one point - how to make sure to only show a customer's data to only that specific customer? And it's not just a security problem, but a performance problem as well. At scale, even with indexes, selecting just the appropriate data can become slow on massive tables.
The "naive" approach is to have a table of customers, and link every other table using foreign keys, and always filter based on the current customer. This approach works fine, and with the library django-scope is pretty safe, but the filter still always needs to be provided and all the data is still in the same physical database table.
Database segregation to the rescue! PostgreSQL has a feature called schemas, which almost acts like a database within a database - each has its own tables and indexes, and you can have many different schemas within one database. In this talk I will introduce you to the django-tenants library, which utilizes these schemas to implement tenanting.
Django-tenants introduces two types of apps, shared apps containing data accessible for all tenants, and tenanted apps specific to one tenant. The data in the tenanted app is only available while the tenant is active, usually based on a subdomain. The django models then work exactly like before, but only the correct data will be returned without any filtering.
In the talk, after walking through a simplified setup of the problem, we'll look at how much simpler django-tenants can make our life while implementing a SaaS application, but also look at certain new and more exciting problems it can bring.
Starting a new software project is exciting! It’s your chance to build something clean, functional, and easy to manage. But without a strong foundation, even small projects can quickly spiral into a confusing mess of bugs, untracked changes, and hard-to-follow code. This is especially true in research environments, where programming often takes a backseat to scientific discovery, and software evolves unpredictably as it adapts to new experiments and shared use. So how do you set yourself up for success from the beginning?
This talk is your beginner-friendly guide to designing smarter, maintainable software using proven design patterns. We’ll explore how patterns like the Singleton (for managing shared resources), the Template Method (for reusable workflows), and the Factory Method (for flexible object creation) can transform your code from fragile and frustrating to solid and scalable.
Using real-world examples from research labs, we’ll walk through how these patterns solve common problems, simplify collaboration, and keep your projects on track, even as they grow. Whether you're developing a new pipeline, a data analysis tool, or an experiment software, this talk will equip you with the foundational knowledge to design software that supports your scientific goals without becoming an unmanageable burden.
Let’s start building research software the right way, so you can focus on science, not debugging.
I want to tell you why monorepos might be the right choice for your project. They’re used at some of the biggest companies in the world, and for good reason - they can vastly simplify and improve some common processes, giving you more logical, legible code.
I did this with a big software rewrite I did at my company last year. I used the open-source monorepo tool Pants to simplify dependency management, refactor across my entire project, integrate my test suites and much, much more.
In this talk, I’ll explain why you might want to rewrite your project into monorepo form. You’ll leave understanding how to use monorepo tooling to manage, test and release your code, with all the concurrency, efficiency and versioning benefits a monorepo has to offer.
Hi Developer, are you dealing or even struggling with:
- pip not being enough to set up your project's environment
- testing your CI workflow locally
- managing complex environments
This talk is for you!
We're going to show you what the real hidden power of the Conda ecosystem, and how you can use it efficiently. Conda is often used for scientific Python development, but it can do much more than that.
With conda, most language tool chains from Java, C++, to Zig and Rust can be installed from the popular conda channel conda-forge.
We will also present pixi which is a modern, fast package and project manager with built-in features facilitating reproducibility and developer comfort. Pixi depends on the conda ecosystem while also fully supporting package installations from PyPI.
Over the years, many myths have been cultivated around the performance of Python. It is high time to debunk some of them, using solid data and years of experience running Python in production.
More importantly, though, we'll talk about when we shouldn't care THAT MUCH about performance and how to balance seemingly contradictory requirements in a constantly changing world.
Using __slots__ on Python classes aims to boost performance, but it can backfire if misconfigured—a common and silent issue often caused by inheritance subtleties. Learn from real-world cases where these problems were found and fixed in major libraries (even the stdlib), undermining intended memory/speed gains.
This talk presents slotscheck, a tool enabling automated testing of __slots__ correctness within your CI/CD pipeline. Learn how to implement effective checks, apply lessons from real-world debugging and fixing, and ensure your use of __slots__ contributes positively to code quality and efficiency. Leave ready to diagnose and fix these silent bugs in your own projects.
When organizing a conference, we often encounter questions such as how to set an appropriate ticket price, how many t-shirts to produce, and how many lunch boxes to estimate. Frequently, our estimates rely on wild guesses, which can lead to inaccuracies. To tackle this issue, we aimed to establish PyCon Taiwan as a data-driven community and formed a data team back in 2021. As the Python community continues to grow with an increasing number of data professionals, this presents a great opportunity for us to attract more volunteers to join PyCon Taiwan.
In our community, we offer an excellent experimental playground for data enthusiasts to test their ideas and explore new technologies. In this talk, I will share how PyCon Taiwan built our internal ETL system using Apache Airflow and discuss our plans to migrate to the soon-to-be-released Airflow 3.0. Additionally, I will explain how we collect data and how it helps us make decisions based on evidence rather than gut feelings.
In today’s data-driven world, handling large datasets efficiently is crucial for any developer or data scientist. Python's itertools module offers a suite of fast and memory efficient tools to handle extensive data iteration, making it a great solution for managing large datasets without exhausting system resources. This talk will dive into several key functions of itertools comparing them to native Python iterations. Attendees will learn how to streamline their code and reduce memory usage while maintaining high performance.
While itertools is part of Python’s standard library, it is often overlooked by many developers in favor of more familiar, but less efficient, native methods. This talk will emphasize the importance of understanding and using these memory-efficient tools, particularly when working with large datasets, where performance and resource management are critical. We’ll begin with a discussion of common challenges developers face when handling large-scale data and why default iteration methods can lead to memory exhaustion or slow performance.
Next, we’ll explore key itertools functions like chain, islice, and cycle, demonstrating how they can drastically reduce memory usage while maintaining high speed. More advanced tools like groupby, product, and permutations will also be covered, showing their relevance in complex data processing scenarios. Real-world examples and benchmarks will clearly illustrate how itertools outperforms native Python approaches in both memory efficiency and speed.
By the end of this session, attendees will not only understand how to incorporate itertools into their workflows but will also gain actionable strategies to write more efficient and optimized Python code. This knowledge will empower them to tackle large datasets with confidence, leading to faster, more scalable applications in data science, software development, and beyond.
If you or your organization are spending time and resources attending a Python conference, you will want to ensure your team gets something immediately actionable and helpful out of it. As coders, we often think about writing code as the only way to contribute. However, pull request reviews are an often overlooked, but highly actionable way to have an impact.
Giving good PR reviews is an art, with two equally important parts: the technical side and the communication side. While the technical side ensures the quality, maintainability, and efficiency of the Python code, the communication around the PR determines whether the feedback can be understood and acted upon. However, we have all seen code reviews that have been ignored or executed poorly due to poor communication.
This talk addresses both facets of PR reviews by introducing the archetypes of bad code reviewers:
1) The “Looks Good to Me” Reviewer: This peer reviewer provides little to no actionable feedback.
2) The “Technical Nitpicker”: This peer reviewer focuses on small Python-specific issues, but fails to
communicate constructively.
3) The “Nit” Commenter: This peer reviewer prefaces every comment with “nit,” while offering unclear, yet technically valid suggestions
Using these archetypes, we will explore Python-specific technical topics (such as pass by reference vs. pass by value), while delving into how to communicate and deliver feedback in a clear and actionable manner. Using real-world examples, attendees will learn how to:
a) Identify and address technical issues in Python PRs
b) Communicate feedback effectively
c) Balance technical rigor with constructive feedback
d) Communicate their peer review comments clearly
Upgrading to a new major version of any Python library can be challenging—especially when your codebase is large and critical to your business. In this talk, we’ll explore a step-by-step approach to managing these upgrades with minimal friction, using our recent migration from Pydantic v1 to v2 as a real-world example. However, all the strategies we discuss can be applied to other Python libraries or frameworks, ensuring your next migration is smooth and stress-free.
You’ll learn how to:
* Identify and Resolve Breaking Changes: Spot incompatibilities early and prevent disruptive failures.
* Refactor for New Features: Adapt your code to leverage the latest improvements and simplify your design.
* Test Safely and Iteratively: Maintain reliability by rolling out incremental changes.
* Achieve Real-World Benefits: Discover how major upgrades can boost performance, reduce complexity, and future-proof your projects.
Whether you work on an enterprise-level system or a small project, you’ll leave with practical insights, best practices, and tools to handle major Python migrations—without the drama.
Enjoy Friday's lightning talks! Short talks about everything by everyone.
Lightning talks are 5 minute talks that anyone participating at the conference can submit.
If that talk gets selected, you will have the chance to jump into the main stage and show us your project, your ideas, something you have learned, something you are proud of that's helping and contributing to our conference and community, or something else!
Be aware: there is a hard-limit on the 5 minutes, you cannot go over, because the host and audience will interrupt you.
Do you know what is a sprint?
The sprints are activities that will happen during the weekend on a different location.
Do you know if you can join? and how can you join?
Do you know all the projects that are participating?
Let us answer these questions and a few more in the Sprint orientation.
What an amazing week!
We had two tutorials days and three talks days filled with amazing topics, but more important, amazing people!
Our community is thankful, and want to close the main conference days.
Join us to get a nice summary of what was EuroPython 2025.