Welcome to EuroPython 2024! 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!

• When: Monday, July 8th.
• Where: Prague Congress Centre (PCC), Room Club D
• Who can join: Anyone with a valid in-person EuroPython 2024 ticket - Conference, Tutorial or Combined (see ticket types for details).

The C API has many different stakeholders, including but not limited to
CPython core developers, maintainers of Python extensions, code generators
(Cython, pybind11, etc) and alternative API design (HPy).

The main goal of this summit is to make sure that people from all these
different projects can meet and discuss about the state of the C API, existing
challenges and ongoing work.

Agenda

• 9:00: Meet and greet - unconference-y post-it based organisation.
• 9:30: Presentations (30 mins each)
• 11:00: Coffee
• 11:15: Presentations
• 12:45: Lunch at the PCC (included)
• 13:45: Unconference-y activities (discussions, hacks, ad hoc tutorials etc…)
• 16:00: Round-up / plenary session for feedback and organising next steps.
• 18:30: Dinner

Registration

You need to have a valid EuroPython in-person ticket (Conference, Tutorial or Combined) to participate. Purchase a EuroPython ticket here, if you haven't already.

The event is limited to 40 participants. If there is a topic you would like to present, please indicate it in the form and fill it in early. Time slots are of 30 min at most (10 min of presentation + 20 min for questions/discussion).

To be part of the C API summit, register your interest now!

We will contact you with more details closer to the event.

Join us as we celebrate a significant milestone: the 10th anniversary of Django Girls, an initiative born at EuroPython 2014 in Berlin.

If you're a woman interested in learning how to build websites, we have fantastic news for you! We are hosting a beginner-friendly, one-day workshop.

We believe the IT industry will greatly benefit from bringing more women into technology. We want to give you an opportunity to learn how to program!

Workshops are free of charge.

We often think about data in terms of storing the current state of our models. If a chess player moves a piece, we update the state of the board and persist it. This makes it easy to query the current state of the game, but also poses some challenges: How do we know which moves led up to the current state? And how do we ensure that the state remains consistent, even in a distributed system?

Event Sourcing takes a different approach to storing state. Instead of storing the current state as-is, we store the sequence of events that led to the current state. If we need to know the current state, we can replay this immutable record of events to reconstruct it. Not only does this give us an immutable audit log, this also promotes loose coupling and enables optimistic concurrency.

In this tutorial, we are going to build an “Event Sourcing”-based backend for a simple Connect 4 game. Rather than using a framework that abstracts away some of the core principles, we are going to implement the mechanisms ourselves to help us understand the core principles.

Outline

• Introduction to Event Sourcing and Domain-Driven Design
• Modeling the events in our game
• Implementing our first events and our aggregate
• Reconstructing state from events
• Persisting the events
• Beyond this tutorial + Q&A

Audience & Preparation

This tutorial is for you if you’re interested in Event Sourcing but don’t have any real experience with it yet. We do expect you to have at least an intermediate level in Python.

Do make sure to bring your laptop, with the following tools installed:
- Python 3.12
- Docker (free-to-use for educational purposes)
- Git
- Your favorite editor

After you've installed everything on your laptop, clone the repository and follow the instructions in the README.md to set up the project.

Remember pointers from C/C++? Why don’t we add them to Python? Make any Python object mutable by manipulating it directly in memory through the pointer as you would do in C/C++. Why do this? Well, pointers have no use in Python, but the point is not implementation itself, but all the internal parts of Python programming language that you will touch while implementing it. What you will learn:

• How to add new piece of syntax to Python. We will implement & and * (address of and dereference) operators just like in C/C++.
• How to add custom builtin object. Adding new syntax has to do something, right? In our case it will operate on new pointer builtin object.
• Internal layout of Python objects.
• How to make our pointer object behave well. Everything in Python is an object and every object internally has to make sure it’s lifecycle does not cause any issues and your program works in a predictable way.
• How to do something with new object. Having new syntax and object is cool, but it has to interact with other objects somehow. Remember double underscore methods like __add__ and __eq__? We will see how they are implemented internally and our object will have them.
• How Python objects are garbage collected. Our pointer object will cover all ways Python objects can be garbage collected and all tricky parts of this process. These involve reference counting and tracing garbage collector for cyclic objects.
• And many more.

Optional: to minimise chances of inconsistencies, it is recommended to have Docker installed

Reproducible dependency management across multiple environments is crucial yet often misunderstood. This hands-on workshop demystifies virtual environments, lockfiles, and how to avoid conflicts when a project needs different dependencies for tasks like testing, documentation, and production.

You'll learn to maintain separate lockfiles per environment using pip's constraint files. Through live coding exercises, you'll set up a full-fledged GitHub project with GitHub Actions CI/CD pipelines that utilize tox/nox to run tests, build docs, and update lockfiles automatically.

By the end, you'll have practiced implementing robust, reproducible environments tailored to each project context, ensuring seamless collaboration and deployment.

Come and join a member of the PyPA and a seasoned contributor to the packaging ecosystem, including pip-tools, walk you through the intricacies of environment reproducibility.

Bring with you

• your laptop
• some editor/IDE
• a few Python versions, something from the range of 3.7-3.13
• pyenv/podman/docker should do as long as you're comfortable
• GitHub account (don't forget your second factor!)
• be able to author and push Git commits
• if your laptop is corporate/limited, web-based environments like Gitpod or GitHub Codespaces should be enough
• on Windows, you'll probably have easier time with WSL 2

Post-workshop materials

A complete implementation of the demonstrated DIY lock files-based environment management is available at https://github.com/webknjaz/ep2024-multilock-toy-template.

Over the years we have many Python extensions written in Rust, for performance, safety/security being the primary reason. This workshop is meant for Python programmers (who may never touched Rust before) to try out writing a fully working extension with various features.

Before workshopp:

• Install Rust via https://rustup.rs
• Install Python development package and dependencies from https://devguide.python.org/getting-started/setup-building/#install-dependencies

• When: Monday, July 8th.
• Where: Prague Congress Centre (PCC), Room Club D
• Who can join: Anyone with a valid in-person EuroPython 2024 ticket - Conference, Tutorial or Combined (see ticket types for details).

The C API has many different stakeholders, including but not limited to
CPython core developers, maintainers of Python extensions, code generators
(Cython, pybind11, etc) and alternative API design (HPy).

The main goal of this summit is to make sure that people from all these
different projects can meet and discuss about the state of the C API, existing
challenges and ongoing work.

Agenda

• 9:00: Meet and greet - unconference-y post-it based organisation.
• 9:30: Presentations (30 mins each)
• 11:00: Coffee
• 11:15: Presentations
• 12:45: Lunch at the PCC (included)
• 13:45: Unconference-y activities (discussions, hacks, ad hoc tutorials etc…)
• 16:00: Round-up / plenary session for feedback and organising next steps.
• 18:30: Dinner

Registration

You need to have a valid EuroPython in-person ticket (Conference, Tutorial or Combined) to participate. Purchase a EuroPython ticket here, if you haven't already.

The event is limited to 40 participants. If there is a topic you would like to present, please indicate it in the form and fill it in early. Time slots are of 30 min at most (10 min of presentation + 20 min for questions/discussion).

To be part of the C API summit, register your interest now!

We will contact you with more details closer to the event.

Join us as we celebrate a significant milestone: the 10th anniversary of Django Girls, an initiative born at EuroPython 2014 in Berlin.

If you're a woman interested in learning how to build websites, we have fantastic news for you! We are hosting a beginner-friendly, one-day workshop.

We believe the IT industry will greatly benefit from bringing more women into technology. We want to give you an opportunity to learn how to program!

Workshops are free of charge.

We often think about data in terms of storing the current state of our models. If a chess player moves a piece, we update the state of the board and persist it. This makes it easy to query the current state of the game, but also poses some challenges: How do we know which moves led up to the current state? And how do we ensure that the state remains consistent, even in a distributed system?

Event Sourcing takes a different approach to storing state. Instead of storing the current state as-is, we store the sequence of events that led to the current state. If we need to know the current state, we can replay this immutable record of events to reconstruct it. Not only does this give us an immutable audit log, this also promotes loose coupling and enables optimistic concurrency.

In this tutorial, we are going to build an “Event Sourcing”-based backend for a simple Connect 4 game. Rather than using a framework that abstracts away some of the core principles, we are going to implement the mechanisms ourselves to help us understand the core principles.

Outline

• Introduction to Event Sourcing and Domain-Driven Design
• Modeling the events in our game
• Implementing our first events and our aggregate
• Reconstructing state from events
• Persisting the events
• Beyond this tutorial + Q&A

Audience & Preparation

This tutorial is for you if you’re interested in Event Sourcing but don’t have any real experience with it yet. We do expect you to have at least an intermediate level in Python.

Do make sure to bring your laptop, with the following tools installed:
- Python 3.12
- Docker (free-to-use for educational purposes)
- Git
- Your favorite editor

After you've installed everything on your laptop, clone the repository and follow the instructions in the README.md to set up the project.

Remember pointers from C/C++? Why don’t we add them to Python? Make any Python object mutable by manipulating it directly in memory through the pointer as you would do in C/C++. Why do this? Well, pointers have no use in Python, but the point is not implementation itself, but all the internal parts of Python programming language that you will touch while implementing it. What you will learn:

• How to add new piece of syntax to Python. We will implement & and * (address of and dereference) operators just like in C/C++.
• How to add custom builtin object. Adding new syntax has to do something, right? In our case it will operate on new pointer builtin object.
• Internal layout of Python objects.
• How to make our pointer object behave well. Everything in Python is an object and every object internally has to make sure it’s lifecycle does not cause any issues and your program works in a predictable way.
• How to do something with new object. Having new syntax and object is cool, but it has to interact with other objects somehow. Remember double underscore methods like __add__ and __eq__? We will see how they are implemented internally and our object will have them.
• How Python objects are garbage collected. Our pointer object will cover all ways Python objects can be garbage collected and all tricky parts of this process. These involve reference counting and tracing garbage collector for cyclic objects.
• And many more.

Optional: to minimise chances of inconsistencies, it is recommended to have Docker installed

Reproducible dependency management across multiple environments is crucial yet often misunderstood. This hands-on workshop demystifies virtual environments, lockfiles, and how to avoid conflicts when a project needs different dependencies for tasks like testing, documentation, and production.

You'll learn to maintain separate lockfiles per environment using pip's constraint files. Through live coding exercises, you'll set up a full-fledged GitHub project with GitHub Actions CI/CD pipelines that utilize tox/nox to run tests, build docs, and update lockfiles automatically.

By the end, you'll have practiced implementing robust, reproducible environments tailored to each project context, ensuring seamless collaboration and deployment.

Come and join a member of the PyPA and a seasoned contributor to the packaging ecosystem, including pip-tools, walk you through the intricacies of environment reproducibility.

Bring with you

• your laptop
• some editor/IDE
• a few Python versions, something from the range of 3.7-3.13
• pyenv/podman/docker should do as long as you're comfortable
• GitHub account (don't forget your second factor!)
• be able to author and push Git commits
• if your laptop is corporate/limited, web-based environments like Gitpod or GitHub Codespaces should be enough
• on Windows, you'll probably have easier time with WSL 2

Post-workshop materials

A complete implementation of the demonstrated DIY lock files-based environment management is available at https://github.com/webknjaz/ep2024-multilock-toy-template.

Over the years we have many Python extensions written in Rust, for performance, safety/security being the primary reason. This workshop is meant for Python programmers (who may never touched Rust before) to try out writing a fully working extension with various features.

Before workshopp:

• Install Rust via https://rustup.rs
• Install Python development package and dependencies from https://devguide.python.org/getting-started/setup-building/#install-dependencies

Maintaining code quality can be challenging, no matter the size of your project or number of contributors. Different team members may have different opinions on code styling and preferences for code structure, while solo contributors might find themselves spending a considerable amount of time making sure the code conforms to accepted conventions. However, manually inspecting and fixing issues in files is both tedious and error-prone. As such, computers are much more suited to this task than humans. Pre-commit hooks are a great way to have a computer handle this for you.

Pre-commit hooks are code checks that run whenever you attempt to commit your changes with Git. They can detect and, in some cases, automatically correct code-quality issues before they make it to your code base. In this tutorial, you will learn how to install and configure pre-commit hooks for your repository to ensure that only code that passes your checks makes it into your code base. We will also explore how to build custom pre-commit hooks for novel use cases.

Prerequisites

• Comfort writing Python code and working with Git on the command line using basic commands (e.g., clone, status, diff, add, commit, and push)
• Have Python and Git installed on your computers, as well as a text editor for writing code (e.g., Visual Studio Code)

Prepare for the workshop

1. Fork and clone this repository.
2. Create a virtual environment for this workshop using whichever tool you prefer.
3. Run pip install pre-commit (or equivalent) in your activated virtual environment.
4. Brainstorm some ideas for your hook.

Feedback?

Let me know what you thought by filling out this feedback form.

• When: Monday, July 8th.
• Where: Prague Congress Centre (PCC), Room Club D
• Who can join: Anyone with a valid in-person EuroPython 2024 ticket - Conference, Tutorial or Combined (see ticket types for details).

The C API has many different stakeholders, including but not limited to
CPython core developers, maintainers of Python extensions, code generators
(Cython, pybind11, etc) and alternative API design (HPy).

The main goal of this summit is to make sure that people from all these
different projects can meet and discuss about the state of the C API, existing
challenges and ongoing work.

Agenda

• 9:00: Meet and greet - unconference-y post-it based organisation.
• 9:30: Presentations (30 mins each)
• 11:00: Coffee
• 11:15: Presentations
• 12:45: Lunch at the PCC (included)
• 13:45: Unconference-y activities (discussions, hacks, ad hoc tutorials etc…)
• 16:00: Round-up / plenary session for feedback and organising next steps.
• 18:30: Dinner

Registration

You need to have a valid EuroPython in-person ticket (Conference, Tutorial or Combined) to participate. Purchase a EuroPython ticket here, if you haven't already.

The event is limited to 40 participants. If there is a topic you would like to present, please indicate it in the form and fill it in early. Time slots are of 30 min at most (10 min of presentation + 20 min for questions/discussion).

To be part of the C API summit, register your interest now!

We will contact you with more details closer to the event.

Join us as we celebrate a significant milestone: the 10th anniversary of Django Girls, an initiative born at EuroPython 2014 in Berlin.

If you're a woman interested in learning how to build websites, we have fantastic news for you! We are hosting a beginner-friendly, one-day workshop.

We believe the IT industry will greatly benefit from bringing more women into technology. We want to give you an opportunity to learn how to program!

Workshops are free of charge.

The ecosystem of MLOps tools and platforms keeps growing by the year and it's difficult to stay up to date. Luckily our industry is now more mature and certain good practices are already well established, but it's still difficult for newcomers to navigate the complexity of production machine learning systems.

What are the minimal pieces that you need to build your MLOps stack? Is there a way to avoid vendor lock-in by stitching open source components together? What are the pros and cons of this approach? What have we learned since 2015, when the seminal Google paper "Hidden Technical Debt in Machine Learning Systems" appeared?

Full outline and instructions at https://github.com/astrojuanlu/workshop-from-zero-to-mlops/

This tutorial is crafted for those new to the concepts of concurrent programming, offering a deep dive into the intricacies of parallelism and concurrency in Python. We will cover basic threading, multiprocessing, concurrent.futures to the advanced asynchronous I/O capabilities of AsyncIO.

Async IO is a concurrent programming design that has received dedicated support in Python; whereas the package in the Python standard library asyncio provides a foundation and API for running and managing coroutines. Whether you're handling I/O-bound or CPU-bound tasks, this tutorial will equip you with the knowledge to write efficient, robust, and high-performing Python applications.

Basic Python programming experience is needed.

In this hands-on tutorial we will reinvent the wheel!

We'll reinvent the wheel and implement the module itertools in plain Python.

We'll do that because it's fun, but also because that will teach us a lot about Python:

• the difference between iterables and iterators;
• what the built-ins iter and next do;
• how Python handles iterations and for loops under the hood;
• what the iterator protocol is;
• how the dunder methods __iter__ and __next__ play a part in all this; and
• we'll also learn about the functions inside itertools, a module with plenty of useful tools for your day-to-day iterations.

To prepare for the tutorial, please
- have Python 3.12+ installed (ideally);
- clone this GitHub repository https://github.com/mathspp/the-little-book-of-itertools; and
- install the requirements (it's just pytest).

Maintaining code quality can be challenging, no matter the size of your project or number of contributors. Different team members may have different opinions on code styling and preferences for code structure, while solo contributors might find themselves spending a considerable amount of time making sure the code conforms to accepted conventions. However, manually inspecting and fixing issues in files is both tedious and error-prone. As such, computers are much more suited to this task than humans. Pre-commit hooks are a great way to have a computer handle this for you.

Pre-commit hooks are code checks that run whenever you attempt to commit your changes with Git. They can detect and, in some cases, automatically correct code-quality issues before they make it to your code base. In this tutorial, you will learn how to install and configure pre-commit hooks for your repository to ensure that only code that passes your checks makes it into your code base. We will also explore how to build custom pre-commit hooks for novel use cases.

Prerequisites

• Comfort writing Python code and working with Git on the command line using basic commands (e.g., clone, status, diff, add, commit, and push)
• Have Python and Git installed on your computers, as well as a text editor for writing code (e.g., Visual Studio Code)

Prepare for the workshop

1. Fork and clone this repository.
2. Create a virtual environment for this workshop using whichever tool you prefer.
3. Run pip install pre-commit (or equivalent) in your activated virtual environment.
4. Brainstorm some ideas for your hook.

Feedback?

Let me know what you thought by filling out this feedback form.

• When: Monday, July 8th.
• Where: Prague Congress Centre (PCC), Room Club D
• Who can join: Anyone with a valid in-person EuroPython 2024 ticket - Conference, Tutorial or Combined (see ticket types for details).

The C API has many different stakeholders, including but not limited to
CPython core developers, maintainers of Python extensions, code generators
(Cython, pybind11, etc) and alternative API design (HPy).

The main goal of this summit is to make sure that people from all these
different projects can meet and discuss about the state of the C API, existing
challenges and ongoing work.

Agenda

• 9:00: Meet and greet - unconference-y post-it based organisation.
• 9:30: Presentations (30 mins each)
• 11:00: Coffee
• 11:15: Presentations
• 12:45: Lunch at the PCC (included)
• 13:45: Unconference-y activities (discussions, hacks, ad hoc tutorials etc…)
• 16:00: Round-up / plenary session for feedback and organising next steps.
• 18:30: Dinner

Registration

You need to have a valid EuroPython in-person ticket (Conference, Tutorial or Combined) to participate. Purchase a EuroPython ticket here, if you haven't already.

The event is limited to 40 participants. If there is a topic you would like to present, please indicate it in the form and fill it in early. Time slots are of 30 min at most (10 min of presentation + 20 min for questions/discussion).

To be part of the C API summit, register your interest now!

We will contact you with more details closer to the event.

Join us as we celebrate a significant milestone: the 10th anniversary of Django Girls, an initiative born at EuroPython 2014 in Berlin.

If you're a woman interested in learning how to build websites, we have fantastic news for you! We are hosting a beginner-friendly, one-day workshop.

We believe the IT industry will greatly benefit from bringing more women into technology. We want to give you an opportunity to learn how to program!

Workshops are free of charge.

The ecosystem of MLOps tools and platforms keeps growing by the year and it's difficult to stay up to date. Luckily our industry is now more mature and certain good practices are already well established, but it's still difficult for newcomers to navigate the complexity of production machine learning systems.

What are the minimal pieces that you need to build your MLOps stack? Is there a way to avoid vendor lock-in by stitching open source components together? What are the pros and cons of this approach? What have we learned since 2015, when the seminal Google paper "Hidden Technical Debt in Machine Learning Systems" appeared?

Full outline and instructions at https://github.com/astrojuanlu/workshop-from-zero-to-mlops/

This tutorial is crafted for those new to the concepts of concurrent programming, offering a deep dive into the intricacies of parallelism and concurrency in Python. We will cover basic threading, multiprocessing, concurrent.futures to the advanced asynchronous I/O capabilities of AsyncIO.

Async IO is a concurrent programming design that has received dedicated support in Python; whereas the package in the Python standard library asyncio provides a foundation and API for running and managing coroutines. Whether you're handling I/O-bound or CPU-bound tasks, this tutorial will equip you with the knowledge to write efficient, robust, and high-performing Python applications.

Basic Python programming experience is needed.

In this hands-on tutorial we will reinvent the wheel!

We'll reinvent the wheel and implement the module itertools in plain Python.

We'll do that because it's fun, but also because that will teach us a lot about Python:

• the difference between iterables and iterators;
• what the built-ins iter and next do;
• how Python handles iterations and for loops under the hood;
• what the iterator protocol is;
• how the dunder methods __iter__ and __next__ play a part in all this; and
• we'll also learn about the functions inside itertools, a module with plenty of useful tools for your day-to-day iterations.

To prepare for the tutorial, please
- have Python 3.12+ installed (ideally);
- clone this GitHub repository https://github.com/mathspp/the-little-book-of-itertools; and
- install the requirements (it's just pytest).

Welcome to EuroPython 2024! 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!

Descriptors are advanced Python features.
While it is possible to write Python programs without active knowledge of them,
knowing more about them facilitates a deeper understanding of the language.
With examples, you will learn how they work and how to write your own
descriptors.
Furthermore, you will understand when to use and when better not to use them.

This tutorial is a systematic introduction to descriptors.
It covers all relevant information with a focus on practical applications for
common tasks.

In hand-on sessions you will learn how to write your own descriptors that adapt
attribute access to your needs.
Use cases provide working code that can serve as a basis for your own solutions.
You will gain a deeper understanding of more advanced concepts that can help
to write better programs.

Software Requirements

You will need a recent Python version installed on your laptop. I will use Python 3.12. I recommend that use this version too. If this is not possible, you may use an older version starting from Python 3.7. There are no other requirements. You will receive the tutorial materials during the tutorial.

JupyterLab

I will use JupyterLab for the tutorial because it makes a very good teaching tool. I recommend that you also use JupyterLab. You may use Notebooks in PyCharm, VS Code, or other systems. If you don't like Notebooks, you are welcome to use the setup you prefer, i.e editor, IDE, REPL.

Since joining NVIDIA I’ve gotten to grips with the fundamentals of writing accelerated code in Python. I was amazed to discover that I didn’t need to learn C++ and I didn’t need new development tools. Writing GPU code in Python is easier today than ever, and in this tutorial, I will share what I’ve learned and how you can get started with accelerating your code.

Are you a complete beginner to coding, but would love to learn how to get started? Have you been curious about data science, but feel overwhelmed with all the talk of AI? Many people working in data science were once in the same position and know how hard it is to take those first steps.

You always wanted to learn programming, but setting it all up felt too intimidating, and the example code was boring? Why not try doing it with a handheld game console that already has everything installed, so you can just start writing the code right away without installing anything on your computer? And why not write some simple video games, like Snake, Tetris, or Flappy Bird? Thanks to the magic of CircuitPython you can now do that. We will walk you step by step through writing a simple video game on 8x8 pixel display. You will learn the basics of programming such as loops, conditionals, handling input and drawing to the screen, all without having to install anything on your laptop.

To participate, you will need a laptop or tablet with a USB socket (and an OTG adapter for the tablets), and any text editor (we recommend https://codewith.mu/). A micro-USB cable will be useful too, but we will have some if you didn't bring yours.

• When: Tuesday, July 9th.
• Where: Prague Congress Centre (PCC), Room Club D
• Who can join: Anyone with a valid in-person EuroPython 2024 ticket - Conference, Tutorial or Combined (see ticket types for details).

This summit aims to bring together maintainers and users of Python with WebAssembly, to discuss the state of this ecosystem, existing challenges, and ongoing work.

Read about last year's summit here.

Agenda

• 9:00: Meet and greet (many of us won’t know each other) + unconference-y post-it based organisation.
• 9:30: Presentations (30 mins each)
• 11:00: Coffee
• 11:15: Presentations
• 12:45: Lunch at the PCC (included)
• 13:45: Unconference-y activities (discussions, hacks, ad hoc tutorials etc…)
• 16:00: Round-up / plenary session for feedback and organising next steps.
• 18:30-ish: Ad hoc dinner plans.

Registration

You need to have a valid EuroPython in-person ticket (Conference, Tutorial or Combined) to participate. Purchase a EuroPython ticket here, if you haven't already.

The event is limited to 40 participants. If there is a topic you would like to present, please indicate it in the form and fill it in early. Time slots are of 30 min at most (10 min of presentation + 20 min for questions/discussion).

To be part of the WASM summit, register your interest now!

We will contact you with more details closer to the event.

For slides and the live demos from the training, please see the GitHub repository.

pytest lets you write simple tests fast - but also scales to very complex scenarios: Beyond the basics of no-boilerplate test functions, this training will show various intermediate/advanced features, as well as gems and tricks.

To attend this training, you should already be familiar with the pytest basics (e.g. writing test functions, parametrize, or what a fixture is) and want to learn how to take the next step to improve your test suites.

If you're already familiar with things like fixture caching scopes, autouse, or using the built-in tmp_path/monkeypatch/... fixtures: There will probably be some slides about concepts you already know, but there are also various little hidden tricks and gems I'll be showing.

Descriptors are advanced Python features.
While it is possible to write Python programs without active knowledge of them,
knowing more about them facilitates a deeper understanding of the language.
With examples, you will learn how they work and how to write your own
descriptors.
Furthermore, you will understand when to use and when better not to use them.

This tutorial is a systematic introduction to descriptors.
It covers all relevant information with a focus on practical applications for
common tasks.

In hand-on sessions you will learn how to write your own descriptors that adapt
attribute access to your needs.
Use cases provide working code that can serve as a basis for your own solutions.
You will gain a deeper understanding of more advanced concepts that can help
to write better programs.

Software Requirements

You will need a recent Python version installed on your laptop. I will use Python 3.12. I recommend that use this version too. If this is not possible, you may use an older version starting from Python 3.7. There are no other requirements. You will receive the tutorial materials during the tutorial.

JupyterLab

I will use JupyterLab for the tutorial because it makes a very good teaching tool. I recommend that you also use JupyterLab. You may use Notebooks in PyCharm, VS Code, or other systems. If you don't like Notebooks, you are welcome to use the setup you prefer, i.e editor, IDE, REPL.

Since joining NVIDIA I’ve gotten to grips with the fundamentals of writing accelerated code in Python. I was amazed to discover that I didn’t need to learn C++ and I didn’t need new development tools. Writing GPU code in Python is easier today than ever, and in this tutorial, I will share what I’ve learned and how you can get started with accelerating your code.

Are you a complete beginner to coding, but would love to learn how to get started? Have you been curious about data science, but feel overwhelmed with all the talk of AI? Many people working in data science were once in the same position and know how hard it is to take those first steps.

You always wanted to learn programming, but setting it all up felt too intimidating, and the example code was boring? Why not try doing it with a handheld game console that already has everything installed, so you can just start writing the code right away without installing anything on your computer? And why not write some simple video games, like Snake, Tetris, or Flappy Bird? Thanks to the magic of CircuitPython you can now do that. We will walk you step by step through writing a simple video game on 8x8 pixel display. You will learn the basics of programming such as loops, conditionals, handling input and drawing to the screen, all without having to install anything on your laptop.

To participate, you will need a laptop or tablet with a USB socket (and an OTG adapter for the tablets), and any text editor (we recommend https://codewith.mu/). A micro-USB cable will be useful too, but we will have some if you didn't bring yours.

• When: Tuesday, July 9th.
• Where: Prague Congress Centre (PCC), Room Club D
• Who can join: Anyone with a valid in-person EuroPython 2024 ticket - Conference, Tutorial or Combined (see ticket types for details).

This summit aims to bring together maintainers and users of Python with WebAssembly, to discuss the state of this ecosystem, existing challenges, and ongoing work.

Read about last year's summit here.

Agenda

• 9:00: Meet and greet (many of us won’t know each other) + unconference-y post-it based organisation.
• 9:30: Presentations (30 mins each)
• 11:00: Coffee
• 11:15: Presentations
• 12:45: Lunch at the PCC (included)
• 13:45: Unconference-y activities (discussions, hacks, ad hoc tutorials etc…)
• 16:00: Round-up / plenary session for feedback and organising next steps.
• 18:30-ish: Ad hoc dinner plans.

Registration

You need to have a valid EuroPython in-person ticket (Conference, Tutorial or Combined) to participate. Purchase a EuroPython ticket here, if you haven't already.

The event is limited to 40 participants. If there is a topic you would like to present, please indicate it in the form and fill it in early. Time slots are of 30 min at most (10 min of presentation + 20 min for questions/discussion).

To be part of the WASM summit, register your interest now!

We will contact you with more details closer to the event.

For slides and the live demos from the training, please see the GitHub repository.

pytest lets you write simple tests fast - but also scales to very complex scenarios: Beyond the basics of no-boilerplate test functions, this training will show various intermediate/advanced features, as well as gems and tricks.

To attend this training, you should already be familiar with the pytest basics (e.g. writing test functions, parametrize, or what a fixture is) and want to learn how to take the next step to improve your test suites.

If you're already familiar with things like fixture caching scopes, autouse, or using the built-in tmp_path/monkeypatch/... fixtures: There will probably be some slides about concepts you already know, but there are also various little hidden tricks and gems I'll be showing.

When you take interesting data from public sources, when you install a highly efficient Python library for data analysis (polars), and you start asking fundamental questions, what can possibly go wrong?

In this course, we will grab public data about the countries of the world and while playing with them, we will explore (a small subset of) what the polars library has to offer. While traditionally the first steps into data analysis are taken with pandas (a true hero in the Python data world), polars is a fresh newcomer that boasts high efficiency and clearly designed API - so why not start with it?

You will learn how to:

• load, manipulate and clean your data;
• gather insights using grouping, aggregation and joining data from various sources;
• understand and present you data visually.

You should possess:

• a modest knowledge of Python (functions, basic containers)
• some familiarity with Jupyter (or some other) notebooks (recommended)
• optionally some knowledge of pandas (not required at all)
• a computer with a pre-installed virtual environment

If possible, come with your laptop prepared - you will find all the installation instructions and notebooks we will be using in the tutorial here: https://github.com/janpipek/eda-polars-way

Are you a complete beginner to coding, but would love to learn how to get started? Have you been curious about data science, but feel overwhelmed with all the talk of AI? Many people working in data science were once in the same position and know how hard it is to take those first steps.

Dive into the realm of mathematical modeling in this hands-on workshop, where numbers unlock insights into disease spread, weather patterns, and financial behaviors. Tom and Gurjot lead a journey spanning Classical Physics, Mathematical Biology, Finance, and Chaos Theory.

From tweaking Mechanics models for surprising outcomes to tracking infectious diseases like COVID-19, each segment offers engaging examples, and an opportunity to understand the uses and applications of calculus and differential equations through the lens of Python.

Suitable for beginners and experts alike, Tom and Gurjot are experienced at using Python for mathematical modelling and are ready to give their thoughts and answer questions, however simple or advanced. Gurjot shares firsthand knowledge from the finance world, unveiling the intricate models shaping modern markets. Tom brings his experience from weather, climate and energy, exploring Chaos Theory's role in weather prediction, and demonstrating tools for understanding atmospheric dynamics.

This interactive session isn't just about learning—it's about empowerment. Armed with Python skills and a deeper understanding of mathematical models, participants gain the confidence to explore further, starting with the notebooks we have refined and expanded for EuroPython 2024.

Join this journey of discovery, where mathematics meets real-world challenges, and Python becomes your toolkit for exploration.

Prerequisites: Jupyter notebook and curiosity :)
[Link to Jupyter notebooks: https://github.com/ThomasGregory/pycon-maths_in_motion/]

Have you ever had to migrate code from one stack to another? Migrating stacks on an application can be a daunting task. The secret is to keep changes to a small size and watch out for blind copy-and-paste.

Join me in this tutorial to learn the key differences between FastAPI and Flask plus how these differences will affect your stack migration.

Learn by doing it: migrate a simple Flask application to FastAPI. Learn how templates work in each framework, how you can use routers to create more complex applications in both Flask and FastAPI, and finally some tips if you are considering migrating from one to the other and vice-versa.

After this tutorial, you will feel confident to start your stack migrations between these two frameworks.

Checkout slides and code here: https://jtemporal.com/flask-to-fastapi

Slides
GitHub repo

During my talk at python users group meetup about using Linux perf profiling in python 3.12 I asked the audience how they find performance issues in their Python code. Out of all respondents:
* More than half simply read the code and find issues with their eyes;
* 10% don't face such problems at all;
* The rest use various profilers.

In this workshop, I would like to influence this distribution and for this.

At the beginning, we will consider the application of CPU profiling to find bottlenecks. We will see how convenient it is to read information with a large volume of reports. How we can first localize to problematic functions, and then to specific lines of code. We will be helped by tools such as pytest-benchmark, cProfile and line_profiler.

Next, it is worth separately considering the problem of memory consumption by our code in Python and looking for places where we do not release it with memory_profiler and py-spy.

Each workshop block will be accompanied by an example and a practical task that you can solve on your laptop. And along the way, ask questions, share results, and discuss the topic of the workshop with other participants and the presenter.

• When: Tuesday, July 9th.
• Where: Prague Congress Centre (PCC), Room Club D
• Who can join: Anyone with a valid in-person EuroPython 2024 ticket - Conference, Tutorial or Combined (see ticket types for details).

This summit aims to bring together maintainers and users of Python with WebAssembly, to discuss the state of this ecosystem, existing challenges, and ongoing work.

Read about last year's summit here.

Agenda

• 9:00: Meet and greet (many of us won’t know each other) + unconference-y post-it based organisation.
• 9:30: Presentations (30 mins each)
• 11:00: Coffee
• 11:15: Presentations
• 12:45: Lunch at the PCC (included)
• 13:45: Unconference-y activities (discussions, hacks, ad hoc tutorials etc…)
• 16:00: Round-up / plenary session for feedback and organising next steps.
• 18:30-ish: Ad hoc dinner plans.

Registration

You need to have a valid EuroPython in-person ticket (Conference, Tutorial or Combined) to participate. Purchase a EuroPython ticket here, if you haven't already.

The event is limited to 40 participants. If there is a topic you would like to present, please indicate it in the form and fill it in early. Time slots are of 30 min at most (10 min of presentation + 20 min for questions/discussion).

To be part of the WASM summit, register your interest now!

We will contact you with more details closer to the event.

When you take interesting data from public sources, when you install a highly efficient Python library for data analysis (polars), and you start asking fundamental questions, what can possibly go wrong?

In this course, we will grab public data about the countries of the world and while playing with them, we will explore (a small subset of) what the polars library has to offer. While traditionally the first steps into data analysis are taken with pandas (a true hero in the Python data world), polars is a fresh newcomer that boasts high efficiency and clearly designed API - so why not start with it?

You will learn how to:

• load, manipulate and clean your data;
• gather insights using grouping, aggregation and joining data from various sources;
• understand and present you data visually.

You should possess:

• a modest knowledge of Python (functions, basic containers)
• some familiarity with Jupyter (or some other) notebooks (recommended)
• optionally some knowledge of pandas (not required at all)
• a computer with a pre-installed virtual environment

If possible, come with your laptop prepared - you will find all the installation instructions and notebooks we will be using in the tutorial here: https://github.com/janpipek/eda-polars-way

Are you a complete beginner to coding, but would love to learn how to get started? Have you been curious about data science, but feel overwhelmed with all the talk of AI? Many people working in data science were once in the same position and know how hard it is to take those first steps.

Dive into the realm of mathematical modeling in this hands-on workshop, where numbers unlock insights into disease spread, weather patterns, and financial behaviors. Tom and Gurjot lead a journey spanning Classical Physics, Mathematical Biology, Finance, and Chaos Theory.

From tweaking Mechanics models for surprising outcomes to tracking infectious diseases like COVID-19, each segment offers engaging examples, and an opportunity to understand the uses and applications of calculus and differential equations through the lens of Python.

Suitable for beginners and experts alike, Tom and Gurjot are experienced at using Python for mathematical modelling and are ready to give their thoughts and answer questions, however simple or advanced. Gurjot shares firsthand knowledge from the finance world, unveiling the intricate models shaping modern markets. Tom brings his experience from weather, climate and energy, exploring Chaos Theory's role in weather prediction, and demonstrating tools for understanding atmospheric dynamics.

This interactive session isn't just about learning—it's about empowerment. Armed with Python skills and a deeper understanding of mathematical models, participants gain the confidence to explore further, starting with the notebooks we have refined and expanded for EuroPython 2024.

Join this journey of discovery, where mathematics meets real-world challenges, and Python becomes your toolkit for exploration.

Prerequisites: Jupyter notebook and curiosity :)
[Link to Jupyter notebooks: https://github.com/ThomasGregory/pycon-maths_in_motion/]

Have you ever had to migrate code from one stack to another? Migrating stacks on an application can be a daunting task. The secret is to keep changes to a small size and watch out for blind copy-and-paste.

Join me in this tutorial to learn the key differences between FastAPI and Flask plus how these differences will affect your stack migration.

Learn by doing it: migrate a simple Flask application to FastAPI. Learn how templates work in each framework, how you can use routers to create more complex applications in both Flask and FastAPI, and finally some tips if you are considering migrating from one to the other and vice-versa.

After this tutorial, you will feel confident to start your stack migrations between these two frameworks.

Checkout slides and code here: https://jtemporal.com/flask-to-fastapi

Slides
GitHub repo

During my talk at python users group meetup about using Linux perf profiling in python 3.12 I asked the audience how they find performance issues in their Python code. Out of all respondents:
* More than half simply read the code and find issues with their eyes;
* 10% don't face such problems at all;
* The rest use various profilers.

In this workshop, I would like to influence this distribution and for this.

At the beginning, we will consider the application of CPU profiling to find bottlenecks. We will see how convenient it is to read information with a large volume of reports. How we can first localize to problematic functions, and then to specific lines of code. We will be helped by tools such as pytest-benchmark, cProfile and line_profiler.

Next, it is worth separately considering the problem of memory consumption by our code in Python and looking for places where we do not release it with memory_profiler and py-spy.

Each workshop block will be accompanied by an example and a practical task that you can solve on your laptop. And along the way, ask questions, share results, and discuss the topic of the workshop with other participants and the presenter.

• When: Tuesday, July 9th.
• Where: Prague Congress Centre (PCC), Room Club D
• Who can join: Anyone with a valid in-person EuroPython 2024 ticket - Conference, Tutorial or Combined (see ticket types for details).

This summit aims to bring together maintainers and users of Python with WebAssembly, to discuss the state of this ecosystem, existing challenges, and ongoing work.

Read about last year's summit here.

Agenda

• 9:00: Meet and greet (many of us won’t know each other) + unconference-y post-it based organisation.
• 9:30: Presentations (30 mins each)
• 11:00: Coffee
• 11:15: Presentations
• 12:45: Lunch at the PCC (included)
• 13:45: Unconference-y activities (discussions, hacks, ad hoc tutorials etc…)
• 16:00: Round-up / plenary session for feedback and organising next steps.
• 18:30-ish: Ad hoc dinner plans.

Registration

You need to have a valid EuroPython in-person ticket (Conference, Tutorial or Combined) to participate. Purchase a EuroPython ticket here, if you haven't already.

The event is limited to 40 participants. If there is a topic you would like to present, please indicate it in the form and fill it in early. Time slots are of 30 min at most (10 min of presentation + 20 min for questions/discussion).

To be part of the WASM summit, register your interest now!

We will contact you with more details closer to the event.

Are you new to EuroPython or any Python conference? You must have a lot of questions like:

What is a Lightning Talk?
What is an Open Space?
Besides going to talk, what else can I do?
Why everyone seems to know each other, how can I join in conversations?

Don't worry, we are here to help you get the most out of your first EuroPython experience. Come to join us in this Beginner Conference Orientation that is tailor made for you.

Welcome to EuroPython 2024! 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 2024.

Let us welcome you officially and tell you all about what's going to await you in the upcoming days.

Today's rapidly evolving software landscape requires agile and informed decision-making. This keynote will highlight the powerful combination of Python, Artificial Intelligence (AI), and heuristics for enabling dynamic decision-making processes.

We will explore the strengths of Python as a versatile language, the potential of AI for intelligent decision support, and the value of heuristics derived from real-world experience. By embracing this synergistic trio, developers can navigate complex challenges, adapt to changing requirements, and make decisions that drive successful software outcomes.

Through practical examples and insights, attendees will gain a deeper understanding of how to leverage Python, AI, and heuristics effectively, striking the right balance between technological innovation and tried-and-true techniques. Whether you're a seasoned developer or just starting your journey, this keynote will equip you with the tools and mindset to embrace agility and make informed decisions that propel your software projects forward.

How do you create an animation?

What if you want to morph a circle into a figure eight?

As it turns out, all you need is two or three functions and a loop!

In this live-coded talk, we'll go over the basic concepts and code needed to create an animation from first principles.

Because the talk presents the ideas and the code from first principles, you will be able to take the key concepts and build your own animations after!

We'll start simple and build from there:

• How can you draw a circle if all you can do is colour single pixels?
• How can you animate the process of drawing a circle?
• How can you animate the process of drawing something other than a circle?
• How can you animate the process of morphing two figures?
• How do you add colour to your animations?

This visually appealing talk will show you all of the code without skipping a single line and by the time we're done you'll be jumping in your seat to create your own animations!

Customers only buy the products they are able to find. Improving the search functions on the website is crucial for user-friendliness.

In our talk we present the lessons learnt from improving the search of our global online marketplace, which sells 20 million products per year. We moved from a traditional word-match based approach (BM25) to a modern hybrid solution that combines BM25 with a semantic vector model, an open-source language model that we fine-tuned to our domain.

With numerous references to current literature, we will explain how we designed our new system and solved the multiple challenges we encountered on both the ML and engineering side (data pipeline encoding documents, live service encoding queries, integration with search engine). Our system is based on OpenSearch, the lessons can be applied to other search engines as well.

In particular the presentation will cover:
- Status and Short-Comings of our old Search
- Introduction of Hybrid Search
- Our Machine Learning Solution
- Architecture and Implementation (with special consideration of latency)
- Learnings and Next Steps

In the world of software development, dealing with legacy code is often a necessary evil, especially for successful, fast-growing companies. The design stamina hypothesis suggests that legacy code is a sign of success, not failure. But how do we tackle this challenge smartly? This talk delves into the often-misunderstood realm of large-scale refactoring and rewrites, presenting a nuanced approach that contrasts with the traditional 'never rewrite' dogma.

We'll delve into real-world case studies where companies have successfully navigated their technical debt, uncovering crucial insights. Specifically, we will identify two key properties of these successful rewrites that can make or break your efforts. Understanding these properties enables us to strategically manage technical debt without losing our competitive edge. This session is not just a theoretical discussion but a practical guide, concluding with a decision-making quadrant to help determine the most effective approach for your team's refactor or rewrite projects. Whether you're leading a team through growth or coaching developers on best practices, this talk will equip you with a deeper understanding and actionable insights into one of the most critical aspects of software development.

Retrieval-Augmented Generation (RAG) is a widely adopted technique to expand the knowledge of LLMs within a specific domain while mitigating hallucinations. However, it is not a silver bullet that is often claimed to be. A chatbot for developer documentation and one for medical advice may be based on the same architecture, but they have vastly different quality, transparency and consistency requirements. Getting RAG to work well on both can be far from trivial.

In this talk we will first understand what RAG is, where it shines and why it works so well in these applications. Then we are going to see the most common failure modes and walk through a few of them to evaluate whether RAG is a suitable solution at all, how to improve the quality of the output, and when it's better to go for a different approach entirely.

Across the industry, programmers of all levels are embracing AI and LLMs. But: it's still worthwhile to learn the foundations of coding. And there's a risk: some learners are using AIs as footguns and limiting their own growth

SPy is a brand new statically typed variant of Python which aim to get performance comparable to system languages such as C and C++, while preserving the "Pythonic feeling" of the language.

The main idea behind SPy is that "modern Python" is actually a subset of Python:

• many of the most dynamic features of the language are considered bad practice and actively discouraged;

• the alway-increasingly adoption of typing leads to codebases which are largerly statically typed.

However, these rules are not enforced by the language, and there are cases in which "breaking the rules" is actually useful and make the code easier/better/faster.

From the point of view of language implementors, the VM cannot easily take advantage of the "mostly static" nature of programs because it has always to be ready for the generic case.

SPy tries to reconcile these two sides:

• it uses a static type system which is designed specifically for safety and performance;

• the vast majority of "dynamic" feature of Python (like decorators, metaclasses, __special_methods__, ...) can be used at zero cost, since they are resolved at compile time by using meta-programming and partial evaluation techniques.

This talk will present in the details the ideas behind SPy and its current status.

Are you curious about integrating the high-performance and memory efficiency of Rust into your Python applications? Rust can significantly enhance the speed and efficiency of Python programs, and this integration is made seamless with PyO3.

This presentation will delve into the capabilities of PyO3, a tool that allows the creation of native Python modules using Rust. With PyO3, importing Rust code as a Python module is straightforward. It offers seamless type conversion between Python and Rust and includes macros that simplify the process of exposing Rust functions to Python.

Moreover, with the growing trend towards asynchronous programming, PyO3-asyncio emerges as a vital tool for those working with async functions in Python or looking to generate Python bindings for an async Rust library. It streamlines the task of translating async functions between Python and Rust. Furthermore, PyO3 facilitates easy implementation of parallelism within Rust code, enhancing performance and efficiency.

Aggregating information is a common Django task, but using the aggregate method can be a bit cumbersome and in the case of large database tables, pretty slow as well. I will introduce the library django-pgviews-redux, which adds first-class support for database views (with Postgres), making that task much simpler.

With that library, database views are wrapped around models, meaning you get many of the features you rely on with models for free, like querysets and filtering on those, admin, and any other feature which works with models. Defining a view is almost as simple as defining a model, by specifying what fields there are for the model and defining the SQL.

This talk will walk through examples of aggregation in Django, and then show how one could simplify those examples using the library. Finally, we will get to materialized views as well, which stores the aggregation almost like a table in the database, providing big speed improvements on aggregation on large tables.

Many real-world problems are inherently multimodal, from the communicative modalities humans use such as spoken language and gestures to the force, sensory, and visual sensors used in robotics. For machine learning models to address these problems and interact more naturally and wholistically with the world around them and ultimately be more general and powerful reasoning engines, we need them to understand data across all of its corresponding images, video, text, audio, and tactile representations.

In this talk, Zain Hasan will discuss how we can use open-source multimodal embedding models in conjunction with large generative multimodal models that can that can see, hear, read, and feel data(!), to perform cross-modal search(searching audio with images, videos with text etc.) and multimodal retrieval augmented generation (MM-RAG) at the billion-object scale with the help of open source vector databases. I will also demonstrate, with live code demos, how being able to perform this cross-modal retrieval in real-time can enables users to use LLMs that can reason over their enterprise multimodal data. This talk will revolve around how we can scale the usage of multimodal embedding and generative models in production.

Writing pipelines for processing large datasets has its challenges – processing data within an acceptable time frame, dealing with unreliable and rate-limited APIs, and unexpected failures that can cause data incompleteness. In this talk we’ll discuss how to design & implement modular, efficient, and manageable workflows with Celery, Redis, and signal-based triggering.

We’ll begin by exploring the motivation behind segmenting pipelines into smaller, more manageable ones. The segmentation simplifies development, enhances fault tolerance, and improves modularity, making it easier to test and debug each component. By leveraging Redis as a data store and Celery’s signals, we introduce self-triggering (or looped) pipelines that efficiently manage data batches within API rate limits and system resource constraints. We will look at an example of how we did things in the past using periodic tasks and how this new approach, instead, simplifies and increases our data throughput and completeness. Additionally, this facilitates triggering pipelines with secondary benefits, such as persisting and reporting results, which allows analysis and insight into the processed data. This can help us tackle inaccuracies and optimise data handling in budget-sensitive environments.

The talk offers the attendees a perspective on designing data pipelines in Celery that they may have not seen before. We will share the techniques for implementing more effective and maintainable data pipelines in their own projects.

FastAPI became one of the most web frameworks in Python. It has an amazing documentation, and easy to use API, which made it very popular. It's easy to start, and as a developer you have a lot of power on what you can do. But... How does it work internally?

In this talk, we will explore the internals of FastAPI. We'll explore the dependency injection system, what are the benefits, and limitations. We'll also see how the routing system works, when the middleware stack runs, how the request and response are handled in detail, how the OpenAPI schema is generated, and the differences between async and non-async endpoints, and how WebSockets fit in the whole picture. Furthermore, we'll also see how the dependencies Pydantic and Starlette help FastAPI on its job.

At the end of this talk, the attendee will understand what's underneath of this very popular package.

"Oh, legal is boring," most developer community thinks in this line. Yes, it is boring, but it is essential at the same time. We will demystify certain basic legal concepts the developers need to know to secure them, their code, and, most importantly, the consequences of their steps. I will go through three fundamental pillars of Intellectual property laws: Trademark, Copyright, and Patent. The talk will include real-life examples of applying all of the above. This talk targets developers and not legal experts.

„Everything’s science fiction until someone makes it science fact.“ - Marie Lu, Warcross

We live in times that have quite a lot of those science facts- even if hoverboards sadly are not part of them- and now have to deal with this new world and all it’s changes for better or for worse.

There are unsettling deepfakes, stunning Cap-Set-Problem-solving language models and the question of artificial conscience. Developers might be able to navigate the turbulences of AI evolution, but are you brave enough to take on the quest of untangling the nebulous scriptures of law that are known to the chaotic neutral wordwizards of the council of Europa as the „AI Act“?

Accompany me on a journey through the valleys of risk-based AI categories, over the sea of subsectional articles and to the top of mount ethic, as we strive to understand the possibilities the AI Act gives our bold heroes to defy the boundaries of innovation, protect the villagers of the EU and construct (legally) safe software.

The Proposal for the European Artificial Intelligence Act takes 224 Pages of legalese to work through.

This talk will give a short overview of what the European AI Act is and about the purpose and necessity of a globally harmonised legal system.

Hopefully it will give an understanding about the main goals of the act, which are, spoiler alert, ensuring AI safety, the protection of fundamental rights, and legal clarity for businesses and developers (which is probably you).

Let us discuss, how developers can shield fundamental rights by writing ethical AI Systems whilst navigating the regulatory landscape and staying tuned with legal development as well.

Many software engineers, particularly web developers, recognize the critical importance of documentation for efficient collaboration. Yet, the challenge of maintaining up-to-date documentation remains a pervasive issue, often due to human errors such as failing to update documentation after changes in the codebase.

This presentation introduces the philosophy of Documentation-First Development (DFD), a methodology I advocate for that leverages the code-based OpenAPI documentation generation capabilities of the FastAPI framework. I will discuss methods to embody this philosophy, including the use of a sub-application pattern to segregate API documents and the application of generic types for crafting reusable custom response models. Additionally, I will address the limitations of traditional approaches to API documentation and demonstrate how FastAPI, in conjunction with Pydantic, offers a more effective solution by automatically keeping documentation synchronized with the code.

This presentation aims to enlighten attendees on the benefits of the FastAPI framework and provide practical insights into creating precise and well-maintained API documentation. It is designed for audiences interested in enhancing their documentation practices and those curious about the advantages of employing FastAPI for web development projects.

Selecting the optimal text embedding model is often guided by benchmarks such as the Massive Text Embedding Benchmark (MTEB). While choosing the best model from the leaderboard is a common practice, it may not always align perfectly with the unique characteristics of your specific dataset. This approach overlooks a crucial yet frequently underestimated element - the tokenizer.

We will delve deep into the tokenizer's fundamental role, shedding light on its operations and introducing straightforward techniques to assess whether a particular model is suited to your data based solely on its tokenizer. We will explore the significance of the tokenizer in the fine-tuning process of embedding models and discuss strategic approaches to optimize its effectiveness.

PEP 729 – Typing governance process proposes a new way to govern the Python type system. The PEP was endorsed by maintainers of all major type checkers. This talk aims to guide the audience to understand the reason more deeply of this new process after demystifying Python types.

In this talk, the speaker will demystify python types from their theory to practice along with Python type systems. The theory includes the type theory by Per Martin-Löf's and gradual typing by Jeremy Siek, all theories will be explained with the Python code in the real world. The type system targets all major type checkers and CPython. The comparison will be based on the research: Python 3 Types in the Wild: A Tale of Two Type Systems. The practice covers how a new specification is done in type systems. In addition, the speaker will share their thoughts about the challenges behind the implementation, and connect the answer to the reason for the PEP 729.

This talk is specifically designed for Python developers and data practitioners who wish to deepen their skills in asynchronous code execution, from single CPU applications to complex distributed systems with thousands of cores. We'll provide a detailed exploration and explanation of Python's asynchronous execution models and concurrency primitives, focusing on Future and Executor interfaces within the concurrent.futures module, and the event-driven architecture of asyncio. Special attention will be given to the processing of large datasets, a common challenge in data science and engineering.

We will start with the fundamental concepts and then explore how they apply to large scale, distributed execution frameworks like Dask or Ray. On step-by-step examples, we aim to demonstrate simple function executions and map-reduce operations. We will illustrate efficient collaboration between different concurrency models. The session will cover the transition to large-scale, distributed execution frameworks, offering practical guidelines for scaling your computations effectively and addressing common hurdles like data serialization in distributed environments.

Attendees will leave with a solid understanding of asynchronous code execution underpinnings. This talk will empower you to make informed practical decisions about applying concurrency in your data processing workflows. You will be able to seamlessly integrate new libraries or frameworks into your projects, ensuring optimal development lifecycle, performance and scalability.

The talk "State-of-the-art image generation for the masses with Diffusers" will explore the diverse applications of the open-source Python library Diffusers in the image and video generation space. The talk will showcase how Diffusers, based on diffusion models, enables fast and high-quality image and video generation, making it accessible to a wide range of users. The presentation will cover various use cases, including image inpainting, image editing, and scene composition, demonstrating the capabilities of Diffusers in enabling users to create and edit photo-realistic images with minimum effort. The audience will gain insights into the potential of Diffusers in revolutionizing the way images and videos are generated and edited, making it a must-attend session for anyone interested in the latest advancements in this field.

Retrieval-Augmented Generation (RAG) presents an excellent approach to overcoming the limitations associated with Large Language Models (LLMs), such as hallucinations or issues related to the recency of their training data. However, relying solely on RAG is insufficient, particularly when dealing with domain-specific data or verifying a response's adequacy. Neglecting these scenarios can cost time, money, and customer satisfaction. That’s why, as you develop an application, it's crucial to evaluate your retrieval process, improve it with advanced techniques if necessary, and consider all edge cases, including handling out-of-domain queries, and implement fallback mechanisms. Thus, you ensure that your system is both resilient and flexible.
This poster will explain some problems you may encounter in real life and which steps to take to build reliable and resilient RAG applications with the open source LLM framework Haystack that you can safely use in production

Hemolytic anaemias are a group of disorders characterised by the loss of integrity of the red blood cell membrane that leads to premature RBC clearance. These conditions often are heterogeneous in the genetic causes, complicating diagnosis by high throughput DNA sequencing. We applied deep learning technologies to build a diagnostic tool for hemolytic anaemias. We used an Imaging Flow Cytometer to obtain images of red blood cell membranes for several hemolytic anaemias and then trained the deep neural network to distinguish the stages of the disease using Keras and TensorFlow. This project combines Python-based machine learning with socially viable healthcare applications.

The new pyproject.toml file gains in popularity. Together with it, some changed to existing packaging tools are happening, especially to setuptools and distutils. The first one is moving away from setup.py support, and the other one was removed from stdlib and merged into the setuptools itself.

But that change isn't scary or bad! Come to my poster and I'll show you how you can migrate away from setup.py while still using setuptools like nothing ever changed!

Python has been evolving very rapidly in the last few years, and this is because new ideas have been taking over the Core Development. New ideas require new people, a new background and lots of energy.

This panel aims for the people to be aware of the changes that are coming in 3.13, and future versions, as well as ways people can contribute by testing features, fixing issues, or even sharing their own ideas.

Host: Konstantin Ignatov
Panelists: Pablo Galindo Salgado, Łukasz Langa, Carol Willing, Hugo van Kemenade, Victor Stinner and Petr Viktorin

GeoPandas is one of the core packages in the Python ecosystem to work with geospatial vector data. By combining the power of several open source geo tools (GEOS/Shapely, GDAL/pyogrio, PROJ/pyproj) and extending the pandas data analysis library to work with geographic objects, it is designed to make working with geospatial data in Python easier. Recently, the development that started more than ten years ago resulted in version 1.0.

This talk will give an overview of what is new in GeoPandas 1.0 and of recent developments in the broader ecosystem of packages on which GeoPandas depends, or that extend GeoPandas. We will highlight some changes and new features in GeoPandas 1.0, such as the new default IO based on pyogrio, closer integration of Shapely 2.0 leading to a range of new methods, and the removal of other geometry engines and consequences of that. We will look at the journey of the GeoPandas from its start at SciPy 2013 to the current 1.0 and discuss the plans moving forward, covering support of spherical geometries, native support for GeoArrow, and more. You will get a sense of what is coming in future, where to help the development and how to prepare your code for upcoming changes.

Ever felt like you’re navigating a data jungle, battling to survive the unexpected production problems that throw you off track? Well, you’re not alone. Staying on top of your data's health is not just smart – it's crucial. In this talk, I will share some Python tricks (methods and libraries) that you can use to defend from those wild data problems. Because let's face it, being able to effectively monitor your data, spot sneaky anomalies, and get to the bottom of them is the key to unlocking a buried treasure.

First, I'll take you through the ins and outs of observability, highlighting its importance for managing both the inputs and outputs of machine learning models, as well as for overall data quality. We'll explore a range of techniques to detect anomalies, with a focus on multivariate time series data. We'll also cover how we can keep this process as computationally efficient as possible.

But we won't stop at just finding these anomalies: we're on a mission to chase them down to their lair! The second part of the talk will equip you with the detective skills to perform root cause analysis and extract as much insights as possible. These discoveries can be an eye opener and the first step towards new projects and strategies. Next, we will also tackle distinguishing real anomalies from data evolution (or drift) and set up effective monitoring strategies to keep your data clean and insightful.

If your interests lie in machine learning or you're simply keen on data quality, join me as we set off to unravel the mysteries of data observability. Let's learn how to keep data problems in check and when life gives you anomalies, turn them into business opportunities!

Want to be a better teammate? Want to get your work merged faster?

For a lot of devs (especially newer ones) the important part of a PR is the code, not the structure of the PR. However, the way commits in a PR are put together to guide a reviewer can be massively impactful. This talk looks at how to effectively craft that review experience.

Using type hints in Python has many advantages, some of which might not be obvious at first. We will see that it allows us to explicitly encode invariants in our code, which reduces the amount of tests that we need to write, it improves development speed and maintainability, and perhaps most importantly, it can give us more confidence that our code does what we expect it to do.

We will also go through code examples that will show us how to leverage typing in Python to design APIs that cannot be easily misused, to create robust programs that we can trust.

Audience members are expected to be able to read and understand Python code.

What does it take to deliver a properly secured API? When we think about API security, we first think of authentication and authorization. But there’s more to it. API security also includes protecting against SQL Injection attacks, Mass Assignment, Excessive Data Exposure, Server-Side Request Forgery (SSRS), and more.

APIs are now the main attack vector on the Internet, and we gotta do something about it. Thankfully, Python boasts excellent libraries for API development, like FastAPI, the Django REST Framework, APIFlask, and more. When used properly, these libraries help us deliver secure APIs.

In this talk, I’ll present a model of Zero Trust Security for APIs that applies robust data validation and sanitization across all data flows to help us deliver secure APIs. You’ll learn how your API design and implementation choices impact API security and how to discover and tackle vulnerabilities.

We’ll walk through practical examples of SQL injection, mass assignment, big payload attacks, pagination attacks, and more. We’ll see how URL parameters and request payloads can become attack vectors when they’re not properly configured.

You’ll also learn how to use tools like schemathesis and Spectral to automate and scale the process of detecting vulnerabilities in your APIs.

By the end of this talk, you’ll be aware of the most important threats to our APIs and you’ll know how to discover and address them effectively. You’ll also get familiar with the concepts of API Security by Design, Shift-Left API Security, and Zero Trust APIs.

No longer needed code creates technical debt if it is not removed from the code base. Unused code has to be maintained, it complicates code base and increases cognitive load. It might even depend on no longer necessary dependencies with vulnerabilities and might increase attack surface. Therefore, removing dead code saves time, money and reduces security risks.

Recently, Ruff has became a de facto linter, which provides almost all existing linting rules from other linters. However, it is only capable to detect locally unused Python code, which is only a tiny portion of unused code.

Vulture is the best known tool for detecting globally unused Python code. However, its configuration is not very flexible and disabling false positives in a larger code base might require a lot of effort.
Also, unused code detection is sometimes inaccurate, because scopes are not taken into account, when detecting unused code.

This presentation introduces a new Python package called deadcode, which tries to move globally unused Python code detection to the next level. First, it provides a large set of options to flexibly disable various types of false positives. Second, deadcode implements more rules for detecting unused code than Vulture. Third, an improved strategy which tracks scopes and namespaces into account is being used to
more accurately identify unused code items. Fourth, a --fix option is provided, which allows to automatically remove detected unused code items.

In addition, an idea to prune Python code in order to reduce its size will be consider, which might be relevant when serving Python code in a browser.

Lets make Python ecosystem even more awesome!

AsyncIO has emerged as a vital tool in Python's ecosystem, particularly in web development, IO-bound tasks, and network programming. However, its internal mechanics often remain obscure, even to seasoned Python developers. This talk aims to demystify AsyncIO by guiding you through creating your own event loop in Python, culminating in running a FastAPI application with it.

In this talk, we’ll build an event loop from scratch in Python, capable of running an HTTP server through a FastAPI application.

Plan:

• Introduction to AsyncIO
• Core Concepts: Deep dive into Event loop, Futures, Tasks, and coroutines
• Hands-On Building: Constructing an event loop from scratch
  • Scheduling callbacks
  • Executing tasks and coroutines
  • Handling network calls
• Practical Application: Running a FastAPI HTTP server with our loop
• Performance Insights: Comparing our event loop with the fastest ones

By the end of this talk, you'll be able to understand the internal workings of AsyncIO and create a basic event loop capable of running a FastAPI application.

We created the “data load tool” (dlt), an open-source Python library, to bridge the gap between data engineers and data scientists. In this talk you will learn about how dlt can help you overcome typical roadblocks in your data science workflows, and how it streamlines the transition from data exploration to production. We will also discuss the pains of maintaining data pipelines and how dlt can help you to avoid common engineering headaches.

Join us to learn best practices around data handling and managing failures with real-life examples!

Pandas has long used NumPy for its back-end storage. But things are changing, and the future of Pandas will likely be tied closely with PyArrow. What are Arrow and PyArrow? How do they affect Pandas users today, and how will they affect us in the future? In this talk, I introduce PyArrow, tell you what it does, how we can already use it in our Pandas work, and whether that's a good idea.

Answer this : In critical domains like Healthcare would you prefer a Jack-of-all-trades OR one Yoda, the master?

Join me on an exhilarating journey as we delve deep into the Mixture of Experts (MoE) technique which is a practical and intuitive next-step to elevate predictive powers of generalised know-it-all models.

A powerful approach to solve a variety of ML tasks, MoE operates on the principle of Divide and Conquer with some less obvious limitations, pros, and cons. You’ll go through a captivating exploration of insights, intuitive reasoning, solid mathematical underpinnings, and a treasure trove of interesting examples!

We'll kick off by surveying the landscape, from ensemble models to stacked estimators, gradually ascending towards the pinnacle of MoE. Along the way, we'll explore challenges, alternative routes, and the crucial art of knowing when to wield the MoE magic—AND when to hold back. Brace yourselves for a business-oriented finale, where we discuss metrics around cost, latency, and throughput for MoE models. And fear not! We'll wrap up with an array of resources equipping you to dive headfirst into pre-trained MoE models, fine-tune them, or even forge your own from scratch. May the force of Experts be with you !"

Ever wished you had a smart fridge that both lists and alerts you with ingredients you have, to waste less food and make the best use of what you have through ingredient-recipe match?

Bingo then that I'll share the story behind the creation of a Python-powered solution that maximizes ingredient usage, minimizes food waste by keeping track of your ingredients and streamlines the cooking process.😊💪

Let's explore together, how snapping a photo of your fridge to generating recipe suggestions based on available ingredients, this project embodies the creativity, problem-solving, and excitement inherent in project development.

Join me as I recount the challenges, and lessons learned along the way, highlighting the transformative impact of project development on skill enhancement and contribution to boost the ways we think as developers. Whether you're a seasoned developer or a curious novice, this talk offers valuable insights into the joys and rewards of turning ideas into reality through coding.

When your programs are configuration driven and used by PM/PO/Scientists etc you have to think slightly differently about how configuration files are used in your projects. For example, users may want to change/create configs on the fly and they may want to see all settings in one file without having to go through layers of indirection and library “configs” to see what their experiment/program will do.

Rather than discussing config file formats (I’ll assume toml but it’s applicable for other formats), this talk will focus more on my ideas/tips on: how to structure config files, how to allow non technical people to contribute to config files, how to minimise potentially explosive number of config files, how to expose more control in config files, tools for testing these configs and checking if values are actually used, hints for good practices to make debugging problems easier.

Every day, as software continues to “eat the world”, applications increasingly grow in complexity.
Nowhere else is this phenomenon more prevalent than in big organizations, which over time have hired more people to develop and maintain more features. There, it is no longer possible to have a complete mental model of what is going on.
Enterprise software, when unchecked, bloats and becomes brittle.
Paradoxically, engineers build software to keep complexity at bay, not to create it. When writing code, the goal is to make processes less labor intensive and more reliable. Yet, enterprise software has become a black hole for man-hours.
Python disrupted Java to become the de facto programming language for enterprises precisely because it tackled this problem in a way that Java, or any other programming language, could not.
How is that so? This talk will dive deep into this exact question. What does Python offer that radically changed how software gets built in organizations, both big and small?. And why is it that newer languages that have come along, such as Go and Rust, haven’t been able to put a dent on its dominions, and have been forced to recede into niche use cases.
This talk is for engineers who want to understand and leverage Python to its maximum maintainability potential. They intuitively understand that Python is a great tool for that, but are unsure as to how to do it.

Event Sourcing (ES) is a powerful concept that lets you adapt your business logic without losing data and past states.
Whether your domain understanding changes or new requirements land on your lap, there is a path forward.
Join us as we talk about some real-world tactics we relied on to manage Event Sourcing in production.
We will accumulate a handful of patterns throughout the talk that will hopefully help you avoid pitfalls and bottlenecks.

Our use cases build on the eventsourcing library, a mature and well-rounded Python library that deserves more attention.
We will tackle the three key aspects of a successful event-sourced application: evolution, projection, and runtime.

Software does not run in a vacuum, models need to change and evolve to reflect the world they live in.
ES records the evolution of how we abstract our domain, how we see things.
Eventually these abstractions can become clumsy or simply inappropriate.
We can deal with that without breaking stride (losing data).

ES also gives us the ability to revisit our perspective and change how we present the application state — by creating new projections and replaying the history.
We will look at how it offers a cheap way to support optimal read-models, which we can can tweak and rebuild in the blink of an eye.

Finally, we will present how such a system actually runs in a typical web application.
Whether in the request loop (synchronous), or through eventual consistency (asynchronous).
As a single process, or distributed for parallel processing.

This talk assumes some familiarity with Event Sourcing and its friends Domain Driven Design (DDD) and Command Query Responsibility Seggregation (CQRS).

PyScript is a platform for Python in the browser, enabled by web-assembly. It brings the rich ecosystems of CPython and MicroPython to the web. Invent is a PyScript based app creation framework with complementary browser based tooling and is designed to be easy to learn and use, no matter if you're a beginner or expert.

This talk introduces Invent, explains how it was built on top of PyScript and describes the design and architecture decisions made to ensure Python and the browser complement each other. Invent apps work anywhere a browser works and by the end of this presentation you'll be armed with all you need to know to build, deploy and extend native Python based applications running atop PyScript on all manner of platforms (mobile, tablet, laptop, desktop, web-enabled fridge, car, point of sale terminal... you name it, so long as there's a browser!).

This talk will be fast-paced, technical, creative, full of possibilities, may include geese 🪿, and will be a lot of geeky fun.

By the end you'll ask yourself, "I wonder what I can invent?" and go create cool stuff in minutes.

Keeping your projects nice and clean helps other to understand your code better and it's crucial when you're working in teams of more than a few people. How do you achieve that?

I'll talk about selected quality control tools, autoformatters, CI, but also about conventions, review process and other details of how we tackle this problem in my workplace. I'll discuss how to introduce changes gradually and keep your repository style and quality checks in sync, even when you have dozens of them. And also about what happens when you overdo it and the tools that should make your life easier actually turn into the torturing machine.

Decorators are powerful, magical syntax sugar, offering a convenient way to wrap and enhance functions. But sometimes, it's not clear how to use a defined decorator.

What arguments should we pass to a given decorator? What functions does it target? Does it change the return type of the wrapped function? Have you ever faced these questions?

If proper type hints are defined for decorators, static type checkers like mypy and pyright IDEs will point out the errors in usage. Thus, guiding you on the right path by catching bugs earlier, reducing unnecessary debugging and unexpected runtime behaviour.

This talk will step you through type definitions utilizing typing.TypeVarTuple, typing.Protocol, typing.ParamSpec, typing.Concatenate, Type Parameter Syntax, and more, all of which are practical to implement and can make your project robust!

In today's fast-paced world, the ability to deliver new features quickly is crucial for product-oriented companies. In this talk, we'll dive into architectural patterns that optimize the delivery of multiple client implementations in complex client-server architectures.

The advent of the mobile age has dramatically altered the landscape of typical client-server models. Delivering a new feature on multiple platforms is complicated and time-consuming because it requires several engineering teams to communicate extensively and separately code and test the same feature in different languages for each platform. Let's see how architectural patterns known as Backend for Frontend (BFF) and Server-driven UI can help with solving these challenges and what the limitations are. We'll explore Python optimizations, caching strategies, and SQLAlchemy preloading techniques, which were crucial to the success of the case study I will share.

This talk aims to provide you with an overview of useful architectural patterns, insights on how to implement and optimize them in Python, and strategies to make your product managers happy by shortening your time to production.

After a huge amount of work from many people, NumPy 2.0.0 has been released, the first major NumPy release since 2006! Among the many new features, several changes to both the Python API and the C API, and a great deal of documentation improvements, there was also a lot of work on improving the performance of string operations.

In this talk, we'll go through the timeline of the changes and the resulting performance improvements, while also diving deep into NumPy ufunc internals and explaining topics like NumPy (parametric) dtypes, type promotion and more.

This is the story of a weekend project which turned into a months long challenge. After coming across a photorealistic painting made entirely out of strings, I wanted to create one on my own. But how? I decided to reverse engineer the algorithm that computes which strings to stretch and in which order.

In this talk, I will show how I created a Python algorithm that produces a beautiful work of art. I will cover topics such as greedy algorithms, image processing, color spaces, performance optimization and many other challenges that I encountered while cracking the algorithm. And of course, I'll show the resulting work of art!

Imagine stepping into your dream job as a python data developer, ready to dive into coding and show your talent, only to run into missing database credentials that leave you idle for days due to slow interdepartmental communications and permission issues. Frustrating, right?

In my talk, I'll showcase how we can make this whole process much easier. I’ll explain how using something called “Identity and Access Management” (IAM) lets everyone in a company, including machines, get to work without these annoying holdups.

Surprised to hear that a machine like Airflow can have its own identity? I'll explain how we use something known as Workload Identity as a crucial part in this ecosystem integrating Airflow within our infrastructure.

A central pillar of the discussion will be the role of impersonation in our setup - how it ties together various elements to enable a harmonious, secure, and maintainable infrastructure. The resulting architecture not only fosters an improved developer experience, faster project delivery, increased productivity and transparency, but also serves as a foundation for more advanced concepts such as data mesh implementation.

Join me in this talk to discover the synergy of IAM, Workload Identity, and impersonation. Let's equip you with a model that promotes easy team onboarding, transparent access management, and a secure, frustration-free workspace focused on delivery.

And for those interested in having their code perform consistently, whether on a local machine or in the cloud, I will share a small but powerful Docker hack to achieve things consistently no matter where your code is running.

With the recent popularity of new programming languages that are improving the Python ecosystem, one cannot dismiss the role of "old" languages like C++, and how the new versions might stay relevant.

With these ideas in mind, how do you bring a huge project, as old as Python, written in C++ to Python?
If you are thinking: «...just create some bindings and call it a day» you will be surprised.

On this talk, we will dive directly into the internals on how the Qt for Python project brought one of the most popular C++ frameworks into Python - but not only with 1-to1 bindings.

We will discuss about build systems, packaging, limited API, interpreters support, Platform and API compatibility, Python and C++ types, ecosystem awareness, CPython code generation, communities, documentation, and many more challenging aspects of maintaining and developing a C++ library in Python.

After this talk, you will not only understand why exposing an existing library from one language to another is much more than just binding them together, but also you will be able to start developing Python applications with Qt.

Have you ever wondered why we are the way we are? Why some individuals develop diseases while others remain healthy? And what does Python have to do with all of this? Join this talk in which we will explore the interface between biology, technology and medicine, in the context of the research of rare genetic diseases. Learn what the Moore’s law has to do with advances in genetics and medicine, or why bigger is not always better.

Enjoy Wednesday's lightning talks! Short talks about everything by everyone. Hosted by Jodie Burchell and Rodrigo Girao Serrao:

• Welcome to Wednesday's Lightning Talks
• EuroPython Game Tournament Announcement — Neil Vaytet
• Czech wines — Jacob Hallén
• How to make a Python meeting with friends — Inácio Medeiros
• Make cron expressions readable again — Fabrizio Damicelli
• Searching For Celebrities With Your Face — Mark Smith
• Named constructors — Austin Bingham
• A backend developer’s entry point to the UI — Luke Purnell
• The Art of Puzzle Solving — Olga Vinogradova

Welcome to EuroPython 2024! 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 news for the day. What's up and what you should know today. Come by and find out what is going to happen today.

We often associate the need for leadership skills with being in a management position. But...we start needing them a lot earlier in our career to succeed and have a positive impact. The diverse workspaces and communities are here to stay, though almost none of us have learned in school how to thrive in diversity. Nor how to be inclusive. We are all somewhere on a journey of inclusive leadership! In this talk we can find out how to asses where we are. And why we should approach inclusive leadership with a beginners mindset, try to do better, make mistakes, learn, repeat. And why we should all be hyped about it.

Whether using threads or task-based event loops, running code concurrently is not without its challenges. This talk takes a look at the features provided by the Python programming language to solve problems of synchronization when dealing with concurrently executing code.

Together we will take a look at the synchronization classes and functions provided by the Python threading and asyncio modules, what problems they aim to solve, and how we might use them effectively in our own code.

Teaching how to program in Python has various approaches, but it becomes motivating when we work with concepts about diversity through poems. This talk will show how a project that aims to teach Python using poems and that grew hand in hand with the Python community has been changing the lives of children and, currently, teachers in a country in the global south. In order to demonstrate it, I will teach you how to create function blocks, conditional and looping structures in an easy and empowering way, while discussing topics such as racism, xenophobia, homophobia, and sexism, for example, through Python code integrated with poetry.

Your data analysis pipeline works. Nice!
Could it be faster? Probably.
Do you need to parallelize? Not yet.

Discover optimization steps that boost the performance of your data analysis pipeline on a single core, reducing time & costs.

This walkthrough shows tools to identify bottlenecks via profiling, and strategies to mitigate those, demonstrating them in an example. To improve our memory and runtime performance we will use numpy, numba jit-ing and pybind11 extensions.

In this modern day and age, 2 things are for certain:

1. Time-to-market for our products & features matters.
2. We can easily drown in complexity and be carried away by over-engineering.

Having the ability to rapidly develop prototypes and proof of concepts is very powerful, because we can iterate towards the right thing, with code.

We know that we can use Django for building mature & long-lasting applications.

But what about building rapid prototypes and proof of concepts?

In this talk, we’ll show that Django can do that job, reliably, as well.

We’ll look at what Django & the rich 3rd party ecosystem has to offer us, when it comes to building rapid prototypes.

We’ll focus on topics like:

1. How to approach rapid prototyping with the correct mindset.
2. Being quick with Django models.
3. Realizing that types can be our friends.
4. Realizing that Django admin may be all the UI we need (at least, in the beginning).
5. Using HTMX where it makes sense.
6. Components in Django templates are a good idea.

The talk will be practical & pragmatic, with the aim to provide good examples, derived from experience, that’ll highlight the main topics and ideas.

The talk is great for both beginners, as well as seasoned Django developers.

The final goal is to give clear evidence, supported by examples, that we can use Django, reliably, to rapidly build prototypes & proof of concepts.

It turns out that Django is all we need.

In this talk, we will explore the basic concepts of Dev Containers and demonstrate how they can support your everyday development as a Python programmer, data scientist, or machine learning engineer. With Dev Containers, you can build a consistent development environment in seconds, no matter where you are or what tools you use. And you know what? The Development Container Specification is even open source. Say goodbye to the hassle of setting up your development environment from scratch every time you start a new project!

We will start with a basic example and discuss how to set up a consistent Python development environment, including best practices for package management and GPU support. After this talk, you will be able to leverage the advantages of Dev Containers, allowing you to work from anywhere and be ready in seconds.

If you're tired of wasting time setting up your development environment and want to unlock the power of Dev Containers, then this talk is a must-attend for you!

Our world is driven by technology and there are many reasons to teach our kids how to code. For example, coding allows them to develop logical reasoning skills and teaches attention to detail. Allowing children to discover how much fun coding can be supports them in their development and opens many doors for their future.

But when and how should we start coding with kids? This talk will approach the question from a scientific perspective, looking into how children's brains develop, how children learn and how to best teach them coding abilities. It will answer important questions like "At what age can a child start coding?" or "What are the benefits of learning to code?". It will also present possible starting points, like learning platforms or tutorials.

The Python development landscape thrives on the extensive use of open-source libraries and frameworks. However, the growing prevalence of attacks targeting OSS underscores the need for robust security measures to consume open source.

In this talk, we'll examine how the Secure Supply Chain Consumption Framework (S2C2F) can guide organizations in securely consuming Python OSS, utilizing tools such as pip, artifact managment, sboms and Dependabot.

The S2C2F Framework was developed by Microsoft and later donated to the Open Source Security Foundation (OpenSSF). It provides a structured approach to enhancing the security of OSS consumption.

We'll provide an overview of its core principles and maturity levels and discuss practical strategies for implementing S2C2F principles within Python projects, including dependency management with pip, artifact management, sboms, signatures, deny rules, forking policies and automated security updates with Dependabot.

The S2C2F is a pragmatic approach to securing how you consume OSS.
It emphasizes the fundamental principles of knowing your OSS, preventing the introduction of vulnerable packages, and maintaining robust patch management.

You will come away from this talk with practical tips and best practices on how to securely consume open source in python.

There are a lot of resources on containerizing Python applications with Docker, but most are basic and outdated. Following them results in slow builds and potentially insecure applications. Let's see how we can build better containers using recent Docker features!

This talk will show how to speed up your builds and make your images smaller and more secure. We'll use features such as multi-stage builds or cache mounts to build containers with Python apps. We will also discuss how to improve the security of your container.

Tips from the talk are valid for applications of all sizes and kinds: from hobby projects to enterprises, from CLI tools to web applications and APIs. You will be able to apply them immediately after the talk.

Basic knowledge of Docker and its key concepts (images, layers, Dockerfile commands) is required. You'll learn something new even if you have used Docker for some time.

The "data build tool" (DBT) was designed to unlock software engineering best practices for SQL-based data pipelines: pipelines as version controlled directed acyclic graphs (DAGs) consisting of testable and reusable nodes. With the increasing number of cloud data warehouses and data lakehouses that allow the native execution of Python code, DBT also added support for Python models.
In this talk, I will explain how Flatiron Health uses DBT to improve and extend lives by learning from the experience of every person with cancer. We will discuss an example project setup that uses SQL as well as Python models. I will share our experiences with unit and data testing as well as with writing a reusable variable library.
The talk is well-suited for anyone with prior data warehouse or data lakehouse experience who is curious how they can leverage DBT to write test-driven and reusable data piplines. The example project will use SQL, Python and Snowflake.

Are web interfaces defined in Python a genius idea, a complete folly, or (like most technologies) a good fit for some use cases but not all?

I'll give a brief tour of packages that let you build web interfaces by writing only Python, including Streamlit, Gradio, NiceGUI, reflex, Solara, dominate, ReactPy and FastUI (recently released by the Pydantic team).

The main three questions I'll be asking are:

1. Is building a web UI in Python really a good idea at all?
2. What fundamental trade-offs are required to make such a tool successful?
3. If someone can answer point 1 and 2, when's the right time to use these tools?

Over the last couple of years, lots of different libraries have emerged to let you develop web interfaces without getting your hands dirty with HTML, CSS, the JS ecosystem; but so far none have got as popular as "traditional" template rendering (Jinja, Django) or modern SPA frameworks like React.

So are we at the dawn of a new way era — and one of these frameworks will become ubiquitous. Or is the whole idea that you can build such an interface without engaging with the fundamental technologies that power them mistaken?

One important question is "what kind of interface are we aiming at?" If we are trying to give complete control over the browser, allowing Python developers to do everything raw JavaScript can do; our solution will look very different to something that is "just" trying to allow Python developers to plug common components together to build 80% of UIs with 20% of the effort.

Looking at the question through this lens will help explain the design choices of the above libraries, and might even allow us to guess at which approaches will be most

We introduce EarthPT -- an open source Earth Observation (EO) pretrained transformer written in Python and PyTorch. EarthPT is a 700 million parameter decoding transformer foundation model trained in an autoregressive self-supervised manner and developed specifically with EO use-cases in mind.

EarthPT is trained on time series derived from satellite imagery, and can accurately predict future pixel-level surface reflectances across the 400-2300 nm range well into the future. For example, forecasts of the evolution of the Normalised Difference Vegetation Index (NDVI) have a typical error of approximately 0.05 (over a natural range of -1 -> 1) at the pixel level over a five month test set horizon, out-performing simple phase-folded models based on historical averaging. We also demonstrate that embeddings learnt by EarthPT hold semantically meaningful information and could be exploited for downstream tasks such as highly granular, dynamic land use classification, crop yield, and drought prediction.

Excitingly, we note that the abundance of EO data provides us with -- in theory -- quadrillions of training tokens. Therefore, if we assume that EarthPT follows neural scaling laws akin to those derived for Large Language Models (LLMs), there is currently no data-imposed limit to scaling EarthPT and other similar ‘Large Observation Models.’

EarthPT is released under the MIT licence here: https://github.com/aspiaspace/EarthPT.

GraalPy is the fast Python implementation built on GraalVM. We run PyTorch and TensorFlow and ML models from Huggingface.co. We execute the test suites of the top 600 PyPI packages every day and are the most compatible alternative implementation of Python to date. We can JIT pure Python code to the same speed as code rewritten in Cython. We are the most seamless and performant choice for integration with Java in both directions, including Jython compatibility mode.

In this talk, we want to show what's possible today with GraalPy and why you might choose it for your projects: for its performance, integration with Java and other languages, or sandboxing and distribution features.

The EU Commission is likely to vote on the Cyber Resilience Act (CRA) later this year. The CRA is an ambitious step towards protecting consumers from software security issues by creating a new list of responsibilities for software developers and providers. The Act also creates a new category of actor known as an “Open Source Steward” which we think makes important allowances for public open source repositories like CPython and Python Package Index (PyPI.) Once the dust settles, everyone who makes software will need to consider the CRA’s mandates in their security roadmaps.

In this talk we will look at the timeline for the new legislation, any critical discussions happening around implementation and most importantly, the new responsibilities outlined by the CRA. We’ll also discuss what the PSF is doing for CPython and for PyPI and what each of us in the Python ecosystem might want to do to get ready for a new era of increased certainty – and liability – around security.

Target audience

Developers and maintainers whose project or product may be affected by the CRA. European legislation won’t just affect the European market, it will affect the software industry and the open source community globally as it is very hard to segregate one project or product from the EU market. So, this is for everyone in the Python community who shares their code with the world.

Goal

To educate the general public about CRA - how it can affect us and how to get ready for it. We also want to provide more information for the Python community about what has been done by the PSF regarding the CRA to reassure them that the Python community is aware and getting prepared for the CRA.

In a time where GenAI is quickly growing in popularity, along with prescriptive analytics and online ML models, the question is raised whether we still need to care about data quality? We strongly believe that the answer is yes, and even more so than before!

Our expectations of data are high, and this often leads to frustrations when reality does not meet these expectations.

In the pursuit of data quality, expectations must be grounded in reality. It is often the case that a gap exists between anticipated outcomes and the actual data reality, which leads to frustration and mistrust.

This talk delves into pragmatic strategies that can be employed to bridge this gap. The talk will discuss both the technical (hard) and cultural (soft) measures implemented to uphold these standards.

Key Takeaways:
1. Integration tests serve as a proactive barrier, preempting the violation of data contracts, unlike reactive data quality checks.
2. Prioritisation is crucial; a product-centric mindset is key when evaluating the balance between resource investment and potential gain.
3. Data quality management is requiring both hard and soft measures

Are you a data scientist, software engineer, product manager, or data engineer? Join us in this discussion; data quality concerns us all.

Would you like to use large language models (LLMs) in your own project, but are troubled by their tendency to frequently “hallucinate”, or produce incorrect information? Have you ever wondered if there was a way to easily measure an LLM’s hallucination rate, and compare this against other models? And would you like to learn how to help LLMs produce more accurate information?

In this talk, we’ll have a look at some of the main reasons that hallucinations occur in LLMs, and then focus on how we can measure one specific type of hallucination: the tendency of models to regurgitate misinformation that they have learned from their training data. We’ll explore how we can easily measure this type of hallucination in LLMs using a dataset called TruthfulQA in conjunction with Python tooling including Hugging Face’s datasets and transformers packages, and the langchain package.

We’ll end by looking at recent initiatives to reduce hallucinations in LLMs, using a technique called retrieval augmented generation (RAG). We’ll look at how and why RAG makes LLMs less likely to hallucinate, and how this can help make these models more reliable and usable in a range of contexts.

Domestic violence is a widespread problem, one which demands attention and policy fixes. But available data is largely unstructured, making analysis difficult for both researchers and policy makers. In this talk, I'll show you how Python helped me to retrieve, structure, and classify violence victims' testimony. I'll show which APIs and libraries allowed me to retrieve the woman's testimony from YouTube, turn their speech into text, and then analyze the text itself. You'll come away knowing not just some new Python techniques, but also how those techniques can be used to improve our society.
Outline:
-Introduction (1m)
- How to collect data from YouTube? (5m)
o reason for collecting data using YouTube
o keywords to find videos
o YouTube API
- How to transcribe audio to text? (5m)
o Whisper API
o how long it took
o accuracy
- Semantic analysis of testimony (10m)
o BERTopic
o Analysis of relevant words
- How useful it is for analyzing unstructured data (10m)
- Conclusion (2m)

In the analytics world, many of the trending data frameworks, written in Python or other languages, are adopting the declarative paradigm: users describe the desired end state, and let the system figure out the best steps to reach that state. This can be seen at many layers: data extraction, data transformation, data visualization, but also infrastructure, data quality, governance... Lots of those frameworks use YAML as the interface between the users (data engineers, data analysts and other data practitioners) and the desired system state.
In this presentation, I propose to dive into the origins of the declarative paradigm for data systems, what it means for us as data practitioners, and why we're actually not becoming glorified YAML developers. I will also talk about state management and GitOps, and probably complain about YAML multiline strings.

As engineers, aspiring or experienced, we can become so focused on growing our technical skills that we forget about the basics. The ability to communicate well can be seen as a skill needed by leaders, managers or client-facing colleagues, but in reality it forms the basis of the quality of our work. From understanding client requirements, to code reviews and even naming variables, communication is a fundamental part of our profession and something we could all benefit from being more conscious of.

In this open-to-all-levels talk we’ll discuss in what situations we should pay closer attention to our style of communication, explore the role of empathy in writing and reviewing code and cover tips and tricks for both making yourself understood and better understanding others.

Documenting Python project endpoints is a real challenge in API development. Poor readability, versioning, and lack of authentication information - this all reduce the usability of existing OpenAPI documentation. The different libraries offers us a good start for autogenerated OpenAPI documentation for our endpoints, but in this talk we will discuss an alternative way to auto generated documentation for our APIs.

Fine-tuning big neural nets like Large Language Models (LLMs) has traditionally been prohibitive due to high hardware requirements. However, Parameter-Efficient Fine-Tuning (PEFT) and quantization enable the training of large models on modest hardware. Thanks to the PEFT library and the Hugging Face ecosystem, these techniques are now accessible to a broad audience.

Expect to learn:

• what the challenges are of fine-tuning large models
• what solutions have been proposed and how they work
• practical examples of applying the PEFT library

Would you believe us if we told you that we could create a potentially dangerous virus using Python? This is theoretically possible thanks to synthetic biology, the field of biotechnology that studies how to create and modify organisms. This discipline is used, for example, to genetically modify bacteria to produce the insulin that diabetics will later use. Obviously, such a powerful tool has its possible evil side, which is what we will explore in this talk. After a little biology and genetics class, we will explain a practical example of how to use synthetic biology through a Python script to modify an existing virus and turn it into a deadly one. Thus, you as an attendee will be able to see the potential of this field and how Python can make it easier, not only in the example of the evil virus, but also in other healthcare applications.

Declaring license metadata in Python packaging has got many pitfalls. The current standard doesn’t meet the needs of the wider public, including downstream packagers (e.g. Linux distributions). Trove classifiers are all but precise. Every build backend comes up with its own idea how to fill in the data in pyproject.toml or their custom formats. It comes hardly as a surprise that there’s an existing attempt to fix the landscape with standardization: PEP 639. In my talk I’ll outline what the proposal is about and how it’s been developing over the years. I’ll summarize the current state and the next steps. This includes the introduction of SPDX expresssion syntax, changes to the project metadata declaration, changes to the core metadata, improved glossary and some more.

The instruction following and in-context learning capabilities of LLMs make them suitable for tackling many NLP tasks. In this talk, we will introduce Scikit-LLM, a rapidly growing, beginner-friendly library that abstracts the complexity of working with LLMs by providing a scikit-learn compatible API. We will showcase how Scikit-LLM can be utilized for solving text classification and text-to-text tasks, and will delve deeper into various methods to improve the model performance, such as prompting strategies and fine-tuning.

In my seven years as a software developer, I've primarily worked in teams composed solely of developers. However, my recent transition to a team of security researchers has opened my eyes to a crucial aspect that often goes unnoticed: log safety in applications.

My exposure to the application security ecosystem and real-life security breach analysis has opened my eyes to recognize code security issues, including the prevalence of sensitive information, tokens, passwords, and payment details, in plaintext logs. This may lead to severe data breaches, financial losses, and all kinds of catastrophes.

This talk will dive into the fatal mistakes developers often make that can result in the disclosure of sensitive information in logs. We'll explore the types of sensitive data in logs.

I'll share my personal experiences as a developer on a security research team and shed light on the often-overlooked consequences of insecure logging practices. We'll discuss practical patterns to safeguard sensitive information in Python applications, including identifying and redacting sensitive data before it reaches log files, and implementing secure logging practices.

By the end of this talk, developers will be equipped with the knowledge and tools to protect sensitive data from accidental disclosure and safeguard their applications from the perils of sensitive data exposure. Embrace the journey towards log safety and ensure your code remains secure and confidential.

Have you ever asked yourself if Large Language Models (LLMs) perform differently across various languages? I have.

In this poster session, I will demonstrate how tokens, embeddings, and the LLMs themselves perform when utilized in 30 different languages. I will illustrate how languages influence pricing and various model characteristics.

Spoiler:
- The Greek language is the most expensive to process by most models.
- Processing Asian languages on Gemini is cheaper.
- You can save up to 15% of tokens by removing diacritics.

As AI continues to integrate into various applications, the ability for different machine learning (ML) models to operate across frameworks is becoming increasingly important. Models are often created and trained using one framework, but must be able to run in different environments, hardware and software engines. The Open Neural Network Exchange (ONNX) is an open standard which addresses this problem. ONNX simplifies the process of moving models between frameworks by offering a common set of operators and a portable file format.

My poster will provide an overview of ONNX and its role in the exchange and deployment of models. We will briefly discuss the architecture of ONNX files, its operator set, which supports a wide range of deep learning models, and the significance of having a standardized model representation in AI development.

ONNX is an open-source project and we are always looking for contributors with good ideas. I want to introduce you to the community behind ONNX and let you know how you can become a part of it. Our community includes representatives of large companies such as Microsoft, Nvidia, IBM and Intel, but also many smaller startups and individuals. Contributing to ONNX is straightforward, based on GitHub pull requests and code reviews. I will tell you about interesting areas where your contribution would be very valueable regardless of your previous expertise level in AI.

The ONNX project thrives on community contributions. Whether you're interested in adding new features, refining existing ones, or improving documentation, there's room for your input. This is an invitation to learn about ONNX and explore ways to contribute to its development.

A standard Django project involves working with multiple files and folders from the start. Let's see how the work with a Django project changes itself when we have only one file in project. This solution automatically transforms Django into a microservice-oriented async framework with "batteries included” philosophy.

Have you ever wondered if Python memory management is playing tricks on you? Starting small, everything runs smoothly. But as your application scales, complexity grows, and memory issues rear their head. You ask yourself, "Is it me or Python memory management?"In this talk, we'll show you how Python memory works, provide tools to analyze memory usage and share practical optimization tips. Whether you're a seasoned Python developer or just starting on your Python journey, this talk is designed to provide you with techniques to overcome Python memory management challenges and write more efficient, memory-conscious code.

Multimedia processing can be very complex, especially if you want to handle most of the available codecs and formats. Fortunately, we have FFMpeg - a "complete, cross-platform solution to record, convert and stream audio and video". It is a great tool, but its CLI is quite complex and challenging to master unless you use it on a daily basis. During this talk, I will tell you what FFmpeg is and how to use it in Python without hurting yourself.

The motivation behind this panel is to provide insights to the audience with regards to funding open source projects, manage the community interaction, and options people might find attractive in order to be paid while doing Open source.

We can also observe the sustainability of a project by the amount of contributors, even if it’s code or activities around it like conferences, communities, and NGOs that support the ecosystem.

In today's data-driven world, privacy stands as an essential requirements for the ethical and effective practice of data science. Moreover, the implementation of robust privacy guarantees in data analysis not only protects sensitive information, but also unlocks the potential for unprecedented democratisation of models and datasets.

PySyft is a stack of open source tools that is designed to help organisations to securely collaborate with external (untrusted) individuals. By using PySyft, organisations can enable external auditors (e.g. data scientists) to use their assets, such as datasets or models, in order to conduct studies with a specific, known purpose. Data scientists can run their analysis using those assets through PySyft, and without seeing nor obtaining a copy of the assets themselves. We call this process Remote Data Science. PySyft is a framework for Remote Data Science.

In the first part of my talk I will introduce the problem of privacy in Data Science, PETs (Privacy Enhancing Technologies), and OpenMined mission to democratise access to data and information. Afterwards, I will demonstrate how PySyft works, and how it can be used to run a machine learning experiments, with privacy guarantees.

When it comes to selecting a high-performance database for your application, RocksDB emerges as a top contender, offering a lightweight and efficient solution. RocksDB brings a robust set of features to the table, but what lies beneath its surface? Let's dive into the world of RocksDB with Python, uncovering the mysteries of its internal workings and exploring the principles that make data storage and retrieval seamlessly efficient. Get ready to equip yourself with the knowledge to harness the full potential of RocksDB and elevate your applications to new heights.

Many of our sponsors are looking to hire talented people and EuroPython is the perfect place to reach out to them!

In this era of rapid technological advancement and AI, Ad prediction systems stand at the forefront of shaping online advertising, significantly impacting how content reaches its intended audience. In this session, I'll introduce the Ads prediction system from a user and algorithm view. We'll then walk through key concepts like targeting, bidding, ad ranking, click-through rate (CTR), and conversion rate. We'll deeply dive into connecting the dots, designing an ad prediction system, some ethical considerations, models, offline and online metrics, scaling and deployment decisions that enable handling high volumes of data and requests efficiently, and some case studies.
At the end of this session, attendees will comprehensively understand the end-to-end process of developing an ads prediction system.

A frequent topic about Python is performance: its interpreted nature inhibits optimisations, and the famous GIL limits parallelism (for now!).

Existing Python Compilers - Cython, Numba, Codon - focus mainly on compiling small, critical bits of code to achieve linear execution speedups. As for parallelism: parallel for-loops powered by OpenMP.

To parallelize highly concurrent programs with concurrent I/O and concurrent tasks, we need more. A key difference is it requires compiling everything: as soon as the Python interpreter comes into play, the GIL will make parallelism collapse.

We introduce Typon, a Python-to-C++ compiler with powerful concurrency primitives powered by a crazy homemade task scheduler. It can take untyped, idiomatic Python code and output C++ code fully independent of the Python interpreter. It also provides seamless to-and-from Python interoperability, for those cases where you really just need to import numpy.

In this talk we'll recount our journey so far: why we think it's important, how we're making something new out of existing bits, what we've achieved. Along the way we might delve into fun details like type inference, concurrency primitives, and C++ pretending-to-be-Python.

You'll come out of this talk with some cool insights into compiler design, concurrency, and the design of Python.

Knowledge of C++ not required. Knowledge of Python language inner workings helpful.

Join us for an illuminating 30-minute journey into the world of design patterns at EuroPython 2024. Design patterns aren't just abstract concepts; they are the architectural blueprints that empower developers to create elegant and maintainable software solutions. In this session, we bridge the gap between theory and practice, offering practical insights for developers of all levels.

We'll delve into a curated selection of design patterns, from foundational creational patterns to advanced behavioral patterns, showcasing their real-world applications and transformative impact on Python development. Through a blend of theory and practice, attendees will gain a comprehensive understanding of how to identify common design problems and apply appropriate patterns to solve them efficiently.

Using engaging examples and hands-on exercises, we'll equip attendees with the knowledge and skills needed to architect cleaner, more maintainable codebases. Whether you're a seasoned veteran or a curious novice, this presentation offers a comprehensive roadmap for mastering Python design patterns and architecting software solutions with grace.

Have you ever wondered how Python gets from the first alpha version upstream to years of stability in your enterprise Linux systems? And what products and useful components are created for you along the way?

In this talk, Lumír will take you through the incredible journey of Python delivery from the first alpha version shipped to Fedora Linux a couple of days after the official upstream release, through containers developers can use for testing with many old and new Python releases in their CI, to Red Hat Enterprise Linux and its main and alternative Python application streams and containers with various Python versions ready to be deployed to production environments with years of required stability.

In this talk, Lumír will talk about:
* Python maintainers’ focus on speed of delivery in Fedora and stability and reliability in RHEL.
* How to use containers based on Fedora for early adoption of new Pythons in CI/CD pipelines.
* What challenges do we face during ten years of maintenance of old Python interpreters.

Come and learn how you can benefit from our efforts, use a modern development environment, and deploy your apps with guaranteed stability.

Caching data and calculation results in jupyter notebooks is a great way to speed up development by making expensive cells easier to re-run.

Data scientists and developers using notebooks on a daily basis, can improve their notebook workflow with low-effort changes in the notebook code, cut the time spent waiting and reduce context switches.

This talk targets developers and data scientist of all experience levels and will cover:

Why caching in notebooks?
Setting up the context in which developers and data scientists use notebooks for exploratory work and how caching is relevant in it.

What is caching
Quick definition of caching, introducing the different types of persistence (in-memory, on disk, database, object storage …), cache invalidation strategies (parameters, code changes, ttl, …), with some cautionary comments about data security when caching protected data.

Caching Techniques
Going through readily available options from the python standard library, and how to use them in notebooks. Introducing a few off-the-shelves options like ipython % magics, and cachetools.
Showcasing how one would build their own mini-caching framework, that fits for their specific use case, using pandas and spark for the example
Explaining when to stop trying to cache, and keeping the caching framework mini, what are the signs that caching went overboard.

Python is an increasingly used language and the number of potential contributors is growing increasingly.

Newcomers to the community have a lot of documentation to guide them to transform from mere users to contributors.

There are many ways to contribute to Python or one of its packages or frameworks, and we will try to see some of them together.

In this talk, new Python developers will discover new ways to get involved in the community, and community members will get ideas for getting new people involved.

More info on my website 👇
https://www.paulox.net/2024/07/11/europython-2024/

With the rise of Generative AI, developers are now able to create a wide range of applications that can generate content from simple prompts and context. In this presentation, we will explore how you can leverage the power of Visual Studio Code, GitHub, and Azure to develop, test, and deploy generative AI applications. We will discuss the latest tools and techniques for building and training generative models, and demonstrate how to build a sample application using GPT-4o, VS Code and its extensions. Additionally, we will showcase how to use GitHub for version control and collaboration, and how to deploy and manage your applications using Azure. For both beginners and veterans, join us to learn how you can master the power of generative AI to create innovative applications.

Pydantic Logfire — Uncomplicated Observability

From the team behind Pydantic, Logfire is a new type of observability platform built on the same belief as our open source library — that the most powerful tools can be easy to use.

In this talk we'll introduce Logfire, then demonstrate how it can make understanding and fixing your app faster and more enjoyable with a live demo.

We'll touch on some of the most useful integrations including: FastAPI, Postgres and OpenAI.

Do you know what RPA means? Or TDD? Or "embedded"? At least, for sure, you know what Python is 😉.

"RPA" stands for "Robotic Process Automation", whereas "TDD" stands for "Test Driven Development". Those words usually refer to either the testing process or the automation of it. In the embedded world - the microcontroller one - it is usually easy to test features unitarily, but hard to test them working within a bigger system.

Therefore... What is this everything about? In this talk Robot Framework is introduced as the tool to integrate almost everything! Firstly, Robot Framework is introduced: Explain its purpose, semantics, basic writing, etc. Then, we will dig a little into it and how to maximize its potential by tweaking the internal libraries and writing our own ones. Next, we will simulate a real embedded device which we require some integration testing: Exchange some messages, evaluate an external request, etc. And finally, we will glue all this together with Robot Framework!

Sounds interesting, right? Jump into this initialization talk for you to get introduced - or acquire more knowledge - into the embedded and testing world.

Have you ever wanted to ship a script or application to a friend or client, without requiring a specific Python installation or providing complex installation instructions ? Or you want to squeeze out that last bit of juice from your Docker Python image to speed up deployment. Then eGenix PyRun is for you.

PyRun is an open source, Apache-licensed, compressed, single file Python compatible run-time, which fits into merely 5 MB on disk.

It can be used to ship pure Python products as a single file on Unix platforms, create Python Docker images with very small footprint to speed up deployment, or as a neat venv replacement, truly isolating applications from any OS or other Python installations, giving you a predictable target for Python applications across Unix platforms.

We have been using PyRun internally at eGenix for many years and open sourced it back in 2012. This year, we are moving the project to Github and relaunching it, in order to present it to the wider open source and Python community.

The talk will go into details on how PyRun is built from the Python source tree, how to create your own single file Python apps, where it can be put to good use, the roadmap we have for PyRun and what its limitations are.

Hey there, fellow Python enthusiasts! Are you ready to dive into the exciting world of application observability without getting your hands too dirty with complex instrumentation? If that sounds like a journey you'd be interested in, then you're in for a treat!

Observability is that magical window into the inner workings of our applications, allowing us to understand what's happening under the hood, troubleshoot issues, and ensure everything is running smoothly. However, achieving this level of insight can sometimes feel like a daunting task. That's where OpenTelemetry comes into play, simplifying the entire process and making it accessible to everyone, not just the observability wizards.

In our session, we'll start with the basics: what OpenTelemetry is and the problems it aims to solve (and those it doesn't). We'll demystify the concept of instrumentation—the process of embedding observability into your applications—and show you how OpenTelemetry makes this not only possible but painless.

The heart of our talk will be focused on autoinstrumentation, a magical feature of OpenTelemetry that automates the task of adding observability to your Python projects. Imagine being able to get detailed insights into your application's performance and behavior without having to manually instrument every nook and cranny. Sounds like a dream, right?

And because we believe in learning by doing, we'll walk you through a small but mighty demo. You'll see firsthand how effortlessly you can implement OpenTelemetry in your own Python applications, turning the daunting into the doable.

Have you ever wished for a feature in Jupyter Notebooks or JupyterLab that wasn't already there? Or perhaps you've found yourself doing complex or repetitive tasks and realized that you, and others, could benefit from integrating those tasks into JupyterLab? This is your chance to learn how to add that feature, or integrate that task, yourself.

JupyterLab enables you to work with Jupyter notebooks, text editors, terminals, and custom components in a flexible, integrated, and extensible manner.

This talk presents a practical tutorial about how to extend JupyterLab. We focus on understanding the underlying extension support infrastructure, as we walk through a step-by-step example of creating an app in JupyterLab. We will learn, among other things, how to launch that app from different places within JupyterLab, how to style our app, and how to pass parameters to our app to modify its behavior.

Prerequisites:
- Attendees should have some familiarity with Jupyter Notebooks and/or JupyterLab.
- Attendees must have solid experience with any typical object-oriented programming language (i.e. a good understanding of classes, objects, and inheritance).

Ever wondered how location planning is done to build city infrastructure? Or when there is a disaster, how do we determine the possible affected areas and send reinforcements there? We require overhead imagery for that, which we mainly obtain from satellites.
European Space Agency has sent various satellites however, the dataset from these satellites is huge and may even contain multiple bands from the electromagnetic spectrum. Large AI models have a huge potential in this domain, if they are developed to work well with this dataset.
There are a lot of pre-trained Generative & Large Vision models on platforms like HuggingFace, Kaggle, etc., but these models do not integrate well with a specific domain like satellite datasets, hence the need to train or fine-tune them. In this talk, we are going to see from where we can access open satellite datasets, fine-tune various Vision Models and Multimodals on it, and examine the following applications:

• Perform Zero-Shot classification and object detection on satellite images with human language input using Multimodal models.
• Image-to-image translation on satellite imagery using generative vision models.

Want to make all your code faster? With matrices, library knowledge, and a sprinkle of creativity, you can consistently speed up multivariate Python functions by 1000x!

Modal optimization requires simple axioms - arithmetic, checking a case, calling the right sklearn function, and so on. When that’s not sufficient, three core tricks - converting conditional logic to set theory, stacking vectors into a matrix, and shaping data to match library expectations - cover the vast majority of real world cases (90% of the ~400 functions we vectorized).

At Bloomberg, ESG (Environmental, Social, and Governance) Scores require complex computations on large data sets. Time-series computations are fundamental for Governance - one UDF infers board support for a policy from prior cyclical votes and other time offset inputs. By rewriting the pandas backfill as a series of reductions on a 4-tensor, we reduced the runtime from 45 minutes to 10 milliseconds! Analogously, due to real world complexity, finance UDFs can end up with 100+ if/else branches in one function. With a mix of De Morgan’s laws and sparse matrix representations, we simplified the cases and achieved 1000x+ speedups.

We’ll conclude with a quick overview of cutting-edge tools, and hope you’ll leave with a concrete strategy for vectorizing financial models!

Mutation testing is a technique for systematically mutating source code in order to validate test suites. It operates by making small changes to a program’s source code and then running a test suite; if the test suite ever succeeds on mutated code then a flag is raised. The goal is to check that a system’s test suite is sufficiently powerful to detect a large class of functionality-affecting changes, thereby helping ensure that the system functions as expected. While not in widespread use, mutation testing is a fascinating topic with great potential that has valuable lessons for the broader software development community.

In this talk we’ll look at Cosmic Ray, an open-source mutation testing tool for Python. Mutation testing presents some difficult and fascinating challenges - both conceptually and from an implementation point of view - so we’ll look at how Cosmic Ray addresses (or plans to address) these complexities. While some of these details will necessarily be Python-specific, there are lessons in Cosmic Ray for the development of mutation in any language.

Mutation testing is still a rather exotic testing technique, but it can produce genuinely useful and surprising results. To show this, we’ll look at a number of cases where Cosmic Ray has helped developers improve their test suites and tighten up their implementations.

Python prides itself on its 'batteries included' philosophy, but beyond the well-trodden modules lie hidden gems awaiting discovery. This talk ventures into the depths of the Python standard library to unearth lesser-known features from itertools, collections, functools, typing and more.

All of these tools are already built into every standard python installation and no "(uv) pip install" is necessary.

Many if not all of those are likely already known to old fashioned pythonistas, but for beginners (1-2years) there will be something new to learn, while for intermediate python developers there might be at least a few more gems to discover.

By delving into these underutilized modules, attendees will gain a richer understanding of Python's built-in capabilities and learn how to write more pythonic code.

Python has a lot of packaging tools and what better way to solve the problem than to add another one. Rye is in many ways just another way to try to fix Python packaging, but it's also happy to not exist if something takes its place. This talk goes over all the lessons learned from writing it, what has lead to it's creation, how it's built internally and what we can do to just solve the problem once and for all.

Enjoy Thursday's lightning talks! Short talks about everything by everyone. Hosted by Velda Kiara and Angel Ramboi:

• Welcome to Thursday's Lightning Talks
• Community Conference / Events Announcements & Celebration!
• What to expect at the social event — Moisés Guimarães
• AutoQuizzer: Can you beat an LLM in a pub quiz? — Bilge Yücel
• Launching Crawlee for Python: Special beta version for EuroPython — Saurav Jain
• Should Python adopt CalVer? 📅 — Hugo van Kemenade
• F*k it — Sébastien Crocquevieille
• Work on sqrt(3) and Pythagoras Theorem — Riccardo Polli
• Present-ception: A presentation about presentations — Siddharth Gupta

Welcome to EuroPython 2024! 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 news for the day. What's up and what you should know today. Come by and find out what is going to happen today.

Codebases often disappoint us, but we keep creating new ones with the absurd hope that it will be different this time. Spoiler alert: it never is.

Notably, research codebases need to fulfil the oxymoron of being robust for long and large computations and highly flexible to experiment with outlandish ideas quickly.

But what if there was a way to break the cycle and build code that endures, even for groundbreaking research.

This talk isn't about magic bullets or silver linings. It's about the powerful connection between healthy teams and healthy code. We'll explore how a healthy team improved the health of a codebase by introducing type annotations and runtime type checking for JAX arrays.

Cython's Limited API support is finally approaching a usable state. As an example, it is possible to produce a working version of Cython by compiling it in Limited API mode.

For users the main advantage is to be able to reduce the number of wheels/binaries they have to build in order to be compatible across a range of versions of Python. For Cython itself there is also an advantage in future-proofing: being able to produce simpler code that should continue to work even as the Python interpreter evolves and which is more likely to work with alternative Python implementations, as well as hopefully placating the unease some of the core Python developers have at Cython's use of Python internals (in non-limited API mode).

This talk will start off by looking at the subject from the users' perspective:
* Why you might want to use the Limited API (from Cython).
* What kind of projects are likely to benefit from it (as far as it's ever possible to predict how people will use a tool...).
* What you actually need to do to build a Cython module with the Limited API.
* What the limitations and disadvantages are: there are some features that don't work, some features that only work in recent versions of Python, some speed costs, and complete forward-compatibility might not be all you hope it would be.

When that "general interest" section is done, I plan to talk about some of the gory implementation details - what "creative" solutions have been employed to work around missing features or things the Limited API was never intended to do.

Retrieval Augmented Generation (RAG) has emerged in recent years as a popular technique at the crossroads of Information Retrieval and Natural Language Generation. It represents a promising new approach that combines the strengths of both retrieval-based systems and generative AI models, aiming to address the limitations of each, while enhancing their overall performance on document intelligence tasks. This talk will introduce the key frameworks, methodologies and advancements in RAG, exploring its ability to empower Large Language Models with a deeper comprehension of context, by leveraging pre-existing knowledge from external corpora. We will review the theoretical foundations, practical applications, and technical challenges associated with RAG, showcasing its potential to impact various fields, such as document summarization or database management. Through this talk, attendees will gain insights into the most relevant topics related to RAG, including token embedding, vector indexing and semantic similarity search.

In the domain of scientific and high-performance computing (HPC), software packages are primarily written in compiled languages such as C, C++, and Fortran, complemented by end-user APIs implemented in Python. Such packages frequently incorporate CPU-specific code (e.g. SIMD extensions) and utilise GPU-specific programming models, such as OpenMP and CUDA, to achieve enhanced performance. Despite the recent proliferation of build backends for creating pure Python packages, the distribution of Python packages containing binary extensions poses a unique set of challenges and currently lacks a standardised solution. In this talk, I will share insights and experiences gained from building portable and performant Python wheels for a set of computational neuroscience projects, aiming for compatibility and usage across a diverse of compute platforms, from desktop to large compute clusters.

I started maintaining open source projects back in 2016 with tox. In 2018, I became a virtualenv maintainer. Today, this has now ballooned to 16 different packages where I'm the primary maintainer (+6 other projects where I help out). On average, these packages get more than 360 million downloads each month.

In this talk, I will share my experience, and explore how I manage to pull this off while also having a primary job and a family. I will present which techniques I tried, what worked, and what did not. I will also share my views on how one should approach maintaining an open source package to avoid burnout.

For most people that use Python, worrying about memory is not an issue. But that's not the case when you have to handle a lot of requests on a large scale. So how do you reduce memory consumption without affecting the CPU?

In this presentation I'll discuss about memory management in Python from the basics, where the necessity for PEP 683 came from, and the changes introduced by it. I also intend to discuss why this PEP is so important for the language, and what we'll be able to achieve with it in the future, such as changes to the GIL and true parallelism.

The talk is targeted for folks who are intermediate/advanced pythonistas. People who are just starting with Python (maybe less than 1.5 years) may feel a bit lost. Even so, curious learners are more than welcome to join, and I'll try my best to make it easy for all audiences on this advanced topic.
After this presentation, participants will learn a bit more about how memory management works under the hood in python, and how it may change in the next couple of years.

Did you know that Python can be used to test foreign code, such as Java and C?
This enables writing tests for legacy code in a very few time, reducing development time and improving code coverage (e.g., using python frameworks to generate testcases for foreign code).
If you have C and Java services that communicates over the network, you can use python as a glue to anticipate some integration tests directly in python.

Sometimes we write code that we don't expect to go to production; they are one-offs or analysis to understand our data. However, a good analysis may be worth repeating, and before we know it, the code that was never supposed to go to production is running every day and driving critical decisions – it is in production. Once our code is in production, we have to maintain it, and that means we need tests to ensure that changes made to the code while maintaining it do not change other behavior.

Hypothesis is a Python library for creating inputs that are good for exercising code. Hypothesis tests create many different inputs for a single test case, with a special concentration on inputs that are likely to break your code. If the code was originally written to understand data, then new data we feed it over time could be very different from what was initially expected or planned for. With Hypothesis, we randomize our test outputs and they become just as unknown as our real-world outputs. Our tests then confirm certain properties to prove that the analysis was performed as expected.

Ghostwriting is a feature of Hypothesis that writes tests based on the type hints in your code. This can not only save time, but also validate our type hints. The savings in time and toil can be significant, but the ghostwritten tests do also need some additions to truly test our code. We'll look at what is needed to both generate proper inputs and check our outputs.

PyPI added support for “Trusted Publishing” last year, allowing package maintainers to create releases directly from their GitHub Actions pipelines without having to worry about token management. Trusted Publishing removes long-lived API tokens from the equation, removing a threat vector for supply chain attacks.
In this talk, we’ll go through the details of how this works, how maintainers can easily take advantage of it with minimal changes to their existing setup, and the ongoing effort in the last 12 months to add support for publishers other than GitHub, such as GitLab, Google, and ActiveState.

Building complex software projects is hard, but the fun part of doing it
is that it often pushes you to find non-obvious solutions to problems
which seem radical at first, yet almost obvious in hindsight. In this
talk you learn some of the unusual Python tricks that we use at EdgeDB
to write more efficient Python with fewer bugs, and which you can apply in
your project next time you need to scratch a similar itch.

The Python C API is used to extend Python and make C libraries accessible in Python. The C API changes often forcing C extensions maintainers to update frequently their code. Also, new binary packages have to be build for each Python version. The stable ABI provides a more stable C API and only require to distribute a single binary package for all Python versions.

In natural language processing, embeddings are crucial for understanding textual data. In this talk, we’ll explore sentence embeddings and their application in dialog systems. We'll focus on a use case involving the classification of dialogs.

We'll demonstrate the necessity of sentence transformers for this problem, specifically utilizing one of the top-performing small-sized sentence transformers. We will show how to fine-tune this model with both labeled and unlabeled dialog data, using the SentenceTransformers Python framework.

This talk is practical, packed with easy-to-follow examples, and aimed at building intuition around this topic. While some basic knowledge of Transformers would be beneficial, it is not required. Newcomers are also welcome.

Everyone who writes also distributes Python code. The only reliable way to share Python code is by packaging it, any other way hurts your consumers. Packaging can be an intimidating topic most would rather avoid but following just a few best practices of packaging can make your code much easier to share, even without going through the process of uploading to pypi.org.

The Update Framework (TUF) has been a prime reference for secure package delivery and updates for many years. Despite its popularity, integrating with existing package managers remains challenging.

PEP 458 is a very good example of some of the related challenges. Authored a decade ago, it aims to protect the freshness, consistency, and integrity of packages in the Python Packaging Index (PyPI) and provide compromise resilience. Even though these goals remain largely unaddressed, PEP 458 has not made its way into production yet!

With Repository Service For TUF (RSTUF), a new tool has emerged, which makes implementing and maintaining a TUF-powered package repository a black box to the repository maintainers and which has become mature enough to kick off an incremental integration in Warehouse and RubyGems.

In this talk, Kairo, RSTUF's tech lead, and Lukas, TUF project maintainer, will show how RSTUF has evolved and allowed us to take a big leap towards adopting TUF in Warehouse and elsewhere. Primers on TUF, PEP 458, and Warehouse will be included.

Proper testing of your Python application doesn't require a rewrite into hexagonal architecture (whatever it means 🤷). In this session, we'll explore battle-tested techniques to enhance the maintainability of your test suite.

• Embracing Well-Known Patterns: The test client or transaction-bound tests are well-established patterns originating from Django. We will explore how to extend these foundational practices within pytest.
• Employing Fixture Factories: How to ensure that our test data clearly cover the intended scenarios? Unpack the utility of fixture factories, streamlining the setup process.
• Mocking without Monkey Patching: Learn effective mocking, steering clear of the problematic practice of monkey patching. We'll explore strategies to achieve accurate testing using favorite frameworks and libraries.
• Covering More with Parametrized Fixtures: Many developers are familiar with pytest fixtures and parametrized tests, but may not be aware of the power of their combination: parametrized fixtures. Discover how to easily build more comprehensive tests.
• Rethinking Test Categorization: The traditional division into unit and integration tests often falls short in practical application. We'll check an alternative approach that can better align with real-world scenarios.

The goal is not merely to report higher coverage but to have tests that can be trusted. By incorporating established patterns, you'll be empowered to focus on what truly matters.

Thread safety is often overlooked when we start with Python for developing simple scripts. But the hidden monster will be unleashed when we try to run non-thread safe code in a multithreaded setup.

We will discuss the problems which can happen when seemingly good code is run in a multithreaded environment. We will walk over the concept of race coditions, how Python’s GIL currently affects multithreading and will cover steps to fix thread unsafe code using synchronization primitives.

Working on one of the major programming languages surely is a lot of fun but sometimes very weird things happen. In these moments Python stops behaving like Python and you enter a new dimension where everything is possible. And debugging what's going on in this new world of weirdness is quite a daunting task given the size of the CPython codebase. In this talk you will learn some of the most obscure, mind-bending and difficult bugs that we faced when developing CPython and how we solve them. You will also learn all the advanced tips and tricks that we used to slay these dragons so you can fight similar monsters in your own codebases or if you want to contribute to CPython itself!

With the emergence of large generative language models there comes a problem of assigning the authorship of the AI-generated texts to its original source. This raises many concerns regarding eg. social engineering, fake news generation and cheating in many educational assignments. While there are several black-box methods for detecting if text was written by human or LLM they have significant issues.

I will discuss how by watermarking you can equip your LLM with a mechanism that undetectable to human eye can give you the means of verifying if it was the true source of a generated text.

chDB, powered by the robust ClickHouse engine, is a high-performance in-process SQL engine designed for the Python data ecosystem. It supports direct interaction with databases like MySQL, PostgreSQL, SQLite, and MongoDB; streaming platforms such as Kafka; and key-value stores like Redis. With extensive support for various data sources and formats, chDB is highly adaptable to different data environments. It seamlessly integrates with structured formats like CSV and JSON as well as complex binary formats such as Parquet, Avro, and Arrow, enabling efficient data manipulation and analysis.
The engine is ANSI SQL compliant, ensuring broad compatibility with existing SQL codebases and facilitating easy integration into diverse data pipelines. This comprehensive SQL support includes complex querying capabilities, enhancing the engine's utility in sophisticated data analysis tasks. chDB is particularly designed to accommodate the rapid prototyping of applications, allowing developers to transition smoothly and quickly from development to production environments with minimal adjustments.
With its deep integration into Python, chDB interacts directly with popular Python libraries such as Pandas, NumPy, and others, streamlining the data science workflow. This integration enables direct data manipulation within Python scripts and notebooks, drastically reducing the need for data movement and conversion, thus accelerating the data analytics process.
For organizations and developers leveraging Python, chDB offers an unmatched combination of performance, flexibility, and ease of use, making it an invaluable tool for building efficient, scalable, and robust data-driven applications.

Unlock the secrets of Python's async and await—tools that let you bend time itself!
In this talk, we'll dive into the magic of asynchronous programming, making your code faster and more efficient.

Learn to handle I/O-bound tasks like a pro, juggle multiple operations without breaking a sweat, and impress your peers with your newfound time-warping skills.
Perfect for those ready to level up from mere mortals to Python sorcerers.

People of all levels of experience are welcome, only requirement is curiosity and enthusiasm :)
Join us, and let’s make time our playground!

In today's world, where disability affects a significant percentage of the population, it is crucial for open-source communities to address the challenges faced by persons with disabilities (PWDs) and work towards their inclusion. This talk will delve into practical measures such as referral programs, internal disability disclosures, and integrating disability into existing agendas rather than treating it as a separate issue. We will dive into disability mainstreaming with a focus on its role in promoting universal design and inclusivity. Attendees will gain insights into establishing disability mainstreaming committees, formulating action plans, implementing best practices, and monitoring and evaluating progress.

Join us for a discussion on navigating tech leadership roles in the dynamic world of technology.

In this talk, we will explore the essence of managerial roles in the tech industry, examining the unique challenges faced by leaders at different levels. We'll discuss the critical decision every developer must make regarding balancing or giving up hands-on expertise with management responsibilities, as well as the challenges of transitioning from a primarily technical role to a managerial position.

Additionally, we'll explore the challenges that managees may face when led by managers and tech leads who may lack management training or experience. We'll also discuss strategies for fostering a more inclusive and supportive engineering culture overall.

Let's talk about management in tech from the perspective of a tech lead that identifies as a woman.

In the evolving landscape of serverless and cloud technologies, Python stands out as a key player for building microservices. Yet, as these systems grow, tracking their performance and catching bugs become increasingly complex.

This presentation introduces OpenTelemetry, a rising standard that equips us with tools to monitor not just Python code but also vital components like databases and message queues. It's designed to blend seamlessly with Python, offering a unified method to collect, process, and share telemetry data across different parts of a distributed system.

This talk starts by discussing the importance of observability in modern distributed environments. Then, we'll dive into OpenTelemetry, focusing on its Python SDK's basics. We'll walk through a hands-on example, showing how to integrate OpenTelemetry into a Python project for automated and manual tracking.

Finally, we'll explore how to leverage the insights gained from OpenTelemetry for more effective system monitoring, ensuring smoother operation and easier troubleshooting.

Starting new python projects should be fun, but often we get bogged down in the details and spend several weeks fine tuning our setup; Not to mention the unproductive time spent on discussions like:

• oh, you are using ruff? I just use black!
• how do you set up your dev environment?
• what version of superFramework are you running?
• can you please update your PR, the tests don't pass.

Let's put a stop to it! We will go through a collection of tools and techniques you can use to set up your new project for success. What to look for and how to make sure you can hit the ground running.

Covered tools/techniques:
Linting, testing, CI, dependency management, editor config, and some more...

Annotating functions with typing information is commonplace nowadays. Annotations have become synonymous with typing information, even though they could be just about anything you’d want. Are there use cases for function annotations other than typing? Is that useful? Should you care? Should you stop using typing?

The goal of redun is to provide the benefits of workflow engines for Python code in an easy and unintrusive way. Workflow engines can help run code faster by using parallel distributed execution, they can provide checkpointing for fast resuming of previously halted execution, they can reactively re-execute code based on changes in data or code, and can provide logging for data provenance.

While there are lots of workflow engines available even for Python, redun differs by avoiding the need to restructure programs in terms of dataflow. In fact, we take the position that writing data flows directly is unnecessarily restrictive, and by doing so we lose abstractions we have come to rely on in most modern high-level languages (control flow, recursion, higher order functions, etc). redun’s key insight is that workflows can be expressed as lazy expressions, that are then evaluated by a scheduler that performs automatic parallelization, caching, and data provenance logging.

redun’s key features are:
- Workflows are defined by lazy expressions that when evaluated emit dynamic directed acyclic graphs (DAGs), enabling complex data flows.
- Incremental computation that is reactive to both data changes as well as code changes.
- Code and data changes are detected using hashing of in memory values, external data sources or source code of individual Python functions.
- Workflow tasks can be executed on a variety of compute backends. (threads, processes, AWS and GCP batch jobs, Spark jobs, etc).
- Past intermediate results are cached centrally and reused across workflows.

Link to the code: https://github.com/insitro/redun/

The identification and measurement of an online audience through the social media platform capitalise on the tonality of emotions on the social media presence. On October 20, the most populous country and acclaimed Africa’s largest economy, Nigeria announced the plans to redesign 200, 500 and 1000 banknotes in replacement of the existing ones. Nigerian citizens expressed different opinions over social media in support of or understanding of the proposed plan and process. Research has shown that shared sentiments on social media can influence the opinions of others and thus the Central Bank of Nigeria's currency redesign policy. This study, therefore, aimed to identify and analyse general sentiments towards the process of the currency redesign policy with the purpose of determining the citizen's attitude towards the policy, based on social media comments. Firstly, sentiment analysis was performed on naira redesign-related posts from a selected social media using lexicon-based and supervised machine learning techniques with the purpose of determining a summarised polarity percentage (i.e. negative or positive). The post was collected between January and February 2023. In addition, the performance of the lexicon-based classifier and seven machine learning-based classifiers was implemented and compared in order to use the best-performing classifier in determining the sentiment polarity of the post. Also, the thematic analysis on both positive and negative posts to further understand and revealed general views about the currency redesign policy. Finally, the analytical findings and the possibility of changing the currency redesign policy was discussed.

During the COVID-19 pandemic, public health researchers have tracked viral genomic mutations to better understand changes in disease severity and transmissibility. The mutation data is often inside large textual files, generated by bioinformatics workflows. Our team developed one such workflow in Python: nf-ncov-voc, which outputs large tabular datasets describing mutation frequencies and locations. To aid researchers in processing and analyzing the datasets, we also developed VIRUS-MVP: a web application that visually summarizes multiple nf-ncov-voc datasets in a single heatmap.

Visually analyzing aggregated mutation data through VIRUS-MVP helps identify links between multiple mutations and distinct virus lineages, including lineages labeled as “variants of concern”. VIRUS-MVP has several interactive features to expedite these analyses, including the ability to jump across genes, search for mutations by name, and toggle mutations by frequency. VIRUS-MVP also annotates mutations with known functions impacting disease severity or transmissibility.

We developed VIRUS-MVP using the Python libraries Plotly and Dash. We selected these libraries to streamline development efforts, as Plotly is a graphing library that draws interactive graphs with minimal code, and Dash is a web framework designed to serve Plotly graphs on a front-end interface. VIRUS-MVP and nf-ncov-voc are both virus-agnostic, but our initial priority was visualizing SARS-CoV-2 data. We deployed this prioritized instance as COVID-MVP at https://virusmvp.org/covid-mvp/, where the application is used by researchers from CoVaRR-Net. We are currently developing instances to also track Mpox and Influenza viruses.

What it’s like to keep the lights on in a rapidly growing business - how we’ve scaled our metrics, logging and tracing beyond processing 50TB+ of telemetry a day, and what we’ve learned along the way.

During this session, we will discuss the challenges of scaling high load services, and give few pointers to developers to help your chosen open-source observebility tool function as a product.

Every second spent waiting for initializations and obscure delays hindering high-frequency logging, further limited by what you can track, an experiment dies. Wouldn’t loading and starting tracking in nearly zero time be nice? What if we could track more and faster, even handling arbitrarily large, complex Python objects with ease?

In this talk, I will present the results of comparative benchmarks covering Weights & Biases, MLflow, FastTrackML, Neptune, Aim, Comet, and MLtraq. You will learn their strengths and weaknesses, what makes them slow and fast, and what sets MLtraq apart, making it 100x faster and capable of handling tens of thousands of experiments.

This presentation will not only be enlightening for those involved in AI/ML experimentation but will also be invaluable for anyone interested in the efficient and safe serialization of Python objects.

Imagine discovering that your brain is equipped in a rare, niche operation system. No wonder the standard software does not suit your hardware and you keep encountering difficult situations… Once you discover it is just software incompatibility and you update the right app versions, the world starts being more comfortable! Unfortunately, few apps only have adapted versions.
It is estimated that neuroatypical people constitute even up to 15-20% of the population. According to “the geek syndrome hypothesis” - autism, but also ADHD are likely to be common in people working in the IT industry. Neurodivergent people have a chance to become wonderful specialists and bring variety to the team thanks to a slightly different perception, special interests or ability to hyperfocus. Their presence can help introduce better practices such as clear communication and transparency. On the other hand, they are at risk of having various troubles in the world adapted to the neurotypical folk.
The author will present the current state of science on neurodiversity, the challenges faced by neurodivergent IT specialists and possible improvements to make the workplace more inclusive for everyone. As a neurodivergent advocate, an IT professional and a biologist with scientific mindset, she will combine her own life and career experience as a neuroatypical person with psychological knowledge which will create a unique perspective. The goal is to prove that neuroatypical people constitute a large part of the IT community and that even small actions can help meet their needs - and not only make their life easier, but also add more creativity to IT teams!

In the realm of Python development, achieving parallelism and harnessing the full power of modern multi-core processors is challenging. Traditionally constrained by the Global Interpreter Lock (GIL), multi-threading was not useful for true parallelism in Python, hence developers turned into multi-processing. Now this is all changing with upcoming developments.
- A new per-Interpreter GIL in Python 3.12 helps to facilitate true parallelism by opening up sub interpreters to run Python codes at the same time. In addition, it is going to be easier to use these features in Python 3.13 by having support for sub interpreters in the Stdlib.
- An upcoming compile option to disable-gil is opening a path to a world with NoGIL where Python threads can truly run in parallel. Which can potentially become the default in the upcoming years.
Multiprocessing, sub-interpreters and multi-threading without GIL are all different ways of facilitating multi-core parallelism in Python. Each of these approaches offers a unique pathway to parallel execution, but comes with its own set of trade-offs, complexities, and suitability for different types of problems. During this talk we will explore each of these options and asses their pros and cons.

Whether you're building CPU-bound high throughput applications, IO-bound services, or simply curious about the future of parallel processing in Python, this talk will help you with the knowledge to make informed decisions and leverage Python's parallel computing capabilities.

Maintaining code quality through effective testing becomes increasingly challenging as codebases expand and developer teams grow. In our rapidly expanding codebase, we encountered common obstacles such as increasing test suite execution time, slow test coverage reporting and delayed test startup. By leveraging innovative strategies using open-source tools, we achieved remarkable enhancements in testing efficiency and code quality.
Challenges Faced:
- Test Suite Execution Time: The duration of test suite execution escalated significantly as we added more tests over time, hampering development speed.
- Slow Test Startup: Complex test setup led to prolonged test startup times, impeding developer productivity.
- Test Coverage Reporting Overhead: Coverage tools introduced substantial overhead and impacted test performance.

Solutions Implemented:
- Parallel Test Execution: We applied pytest-xdist to distribute tests across multiple runners, significantly reducing test suite execution time and enabling faster development iterations.
- Optimized Test Startup: Pre-installing dependencies in a Docker image and utilizing Kubernetes for auto-scaling continuous integration runners helped expedite test startup times, improving developer efficiency. For local development, we used pytest-hot-reloading to reload tests fast after code editing.
- Efficient Test Coverage Reporting: Customizing the coverage tool to collect data only on updated files of pull requests minimized overhead on test coverage reporting.
As a result, in the past year, our test case volume increased by 8000, test coverage was elevated to 85%, and Continuous Integration (CI) test duration was maintained under 15 minute

I, an undercover Imposter Syndrome sufferer, masquerade as a Staff Software Engineer amid an army of coding geniuses. Imagine you're playing a video game where you're pretending to be a powerful leader, but deep down, you're convinced you're not really good enough. That's my daily life as a staff software engineer leading a team, except it's not a game, and the 'quit' button doesn't work. In this talk, I'll tell you about my hilarious misadventures and unexpected triumphs in the rollercoaster ride of being a staff software engineer and how my team still manages to create cool things despite my 'imposter' moments.

In this talk, we dive into the world of Event Driven Architecture and Message Streaming, using Python and FastStream.

You'll learn to integrate FastStream, a python framework, into your projects and leverage AsyncAPI to define contracts for asynchronous communication and event streaming. Through practical examples and insights, you'll discover the art of building scalable, responsive Python applications that thrive in real-time environments.

About AsyncAPI

AsyncAPI is an open standard/specification and growing set of open-source tools to help developers define, build, and maintain asynchronous APIs and Event-Driven Architectures. It describes message-driven APIs in a machine-readable format, and is protocol-agnostic.

About FastStream

FastStream is a powerful and easy-to-use Python framework for building asynchronous services interacting with event streams such as Apache Kafka, RabbitMQ, NATS and Redis. FastStream simplifies the process of writing producers and consumers for message queues, handling all the parsing, networking and documentation generation automatically. FastStream provides unified API across multiple brokers, built-in Pydantic validations, automatic AsyncAPI documentation, FastAPI like Dependency Injection System, built-in support for test and extensions.

Bloomberg is a leading provider of financial data, with information spanning multiple decades. Handling and organizing these huge datasets can be challenging, with typical concerns including sluggish query performance, high storage costs, and data consistency problems.
This talk will describe how Apache Iceberg is revolutionizing big data management, offering ACID transactions, time travel, and seamless schema evolution that enable lightning-fast query performance and robust data consistency for even our largest workloads.
The session will introduce Apache Iceberg, an open-source table format that enables incremental updates, versioning, and schema evolution. The discussion will focus on how these features address common big data management challenges, improve query performance, and reduce storage costs. Finally, the session will outline how our Enterprise Data Lake Applications engineering team has harnessed the capabilities of Apache Iceberg (especially PyIceberg) to revolutionize our data management and analytical processing workflows.
Attendees will be able to apply the best practices discussed in the talk to build better infrastructure for their growing data demands and spur innovation within their organization.

Most Python programmers are probably aware that Python supports multiple inheritance. However, few are likely to be aware of its implications and inner workings. This talk aims to shed light on this commonly overlooked topic.

In the first part of the talk we will start by reviewing the “diamond problem,” where a class inherits from two classes that have a common ancestor, and contrast how this issue is handled in Python compared to other object oriented languages. Next, we will discuss the Method Resolution Order (MRO) to see how Python determines the sequence in which classes are considered when searching for a method or attribute. We will also review the use of the super() function that allows a subclass to call a method from its superclass in a way that adheres to the MRO.

During the second part of the talk, we will explore real-world scenarios related to the benefits, problems, and alternatives of using multiple inheritance in our programs. We will dedicate some time to examining the concept of a mixin and how to implement it effectively in Python. Finally, we will delve into the Interface Segregation Principle and explore collaboration and composition as mechanisms for avoiding the pitfalls of inheritance in general.

Nowadays, if you attend an event you're bound to end up with a catalogue of photographs to look at. Formal events are likely to have a professional photographer, and modern smartphones mean that it's easy to make a photographic record of just about any gathering. It can be fun to look through the pictures, to find yourself or your friends and family, but it can also be tedious.

At our company get-together earlier in the year, the photographers did indeed take a lot of pictures. Afterwards the best of them were put up on our internal network - and like many people, I combed through them looking for those in which I appeared (yes, for vanity, but also with some amusement).

In this talk, I'll explain how to automate finding the photographs I'm in (or at least, mostly so). I'll walk through Python code that extracts faces using OpenCV, calculates vector embeddings using imgbeddings and OpenAI, and stores them in PostgreSQL® using pgvector. Given all of that, I can then make an SQL query to find which pictures I'm in.

Python is a good fit for data pipelines like this, as it has good bindings to machine learning packages, and excellent support for talking to PostgreSQL.

You may be wondering why that sequence ends with PostgreSQL (and SQL) rather than something more machine learning specific. I'll talk about that as well, and in particular about how PostgreSQL allows us to cope when the amount of data gets too large to be handled locally, and how useful it is to be able to relate the similarity calculations to other columns in the database - in our case, perhaps including the image metadata.

"Everything in Python is an object." This is a profound truth about Python, but what does it mean? Is literally EVERYTHING an object? And what is an object anyway? Are objects the same as instances of a class? How do classes and types really work in Python? And what do metaclasses have to do with anything?

In fact, the answers to these questions are probably not what you think they are - Python's approach to objects is different from most other languages in sometimes surprising ways.

This talk will use simple live coded examples to explore how objects work in Python and clear up several common misconceptions and misunderstandings about how objects and instances, classes and types, and metaclasses all work together.

Be warned - you are likely to be surprised when you learn the truth about objects in Python.

Fully Homomorphic Encryption (FHE) is a privacy-enhancing technology that enables performing computations over encrypted data. FHE has recently seen a lot of progress, and commercial applications of FHE are now available. One of the main application domains for FHE is privacy-preserving machine learning. We introduce a Python interface for OpenFHE, a popular open-source FHE C++ software library that supports all common FHE schemes. OpenFHE is a NumFocus-sponsored open-source project that has been authored by a community of well-known FHE cryptographers and software engineers.The talk provides a high-level introduction to FHE and its applications, and then provides an overview of the Python API. Several examples are presented to both illustrate FHE concepts and show the practicality of the technology.

More information about the OpenFHE project:
* Main website: https://www.openfhe.org/ ;
* OpenFHE discourse forum: https://openfhe.discourse.group/ ;
* Main OpenFHE repository: https://github.com/openfheorg/openfhe-development ;
* OpenFHE organization: https://github.com/openfheorg ;
* Main OpenFHE design paper: https://eprint.iacr.org/2022/915 ;

Have you heard we've got a nice new REPL in 3.13? Let's make some music with it in real time. You've had an intense conference. How about you sit back and relax and watch a music performance constructed before your very eyes? We'll be interacting with hardware synthesizers and drum machines, and even showing visualizations, but most importantly we will be writing Python, lots of Python. Consider it a demo of PyREPL and some other features of Python 3.13.

Enjoy Friday's lightning talks! Short talks about everything by everyone. Hosted by Elise Kasai and Mark Smith:

• Welcome to Friday's Lightning Talks
• Community Conference / Events Announcements & Celebration!
• OpenFHE - Matrix Arithmetic Library — Sukanya Mandal
• A mysterious case of distorted 3D models — Miro Hrončok
• How to from italia import 🤌 — Ester Beltrami
• How the cycle Garbage Collection works — Mark Shannon
• A EuroPython Poem — Emma Cooke
• Testing Hardware Specs with pytest — Thomas Ganahl
• Presentation slides dos and don'ts — Reuven Lerner
• Who wants to be a millionaire? — Rodrigo Girão Serrão
• Level Up Your Presentations with Better Screenshots — Rudolfs Berzins
• Python C++ API with Nanobind — Fernando Pereira
• self.optimize() to become a better programmer — Muzher Sharif

What is a sprint?
Where are they going to take place?
Can I even join? And how?

Let us answer these questions and a few more in the Sprint orientation

That's it for the tutorial and talks. Thank you all and before we all use what we learned let's have a short recap.