PyCon Sweden 2025

TBD

Welcome to PyCon Sweden 2025!

The current hype around AI can feel like something totally new, but it’s not the first time we’ve been here. In fact, this is the third AI era in the past 70 years. Each one came with huge excitement, massive promises, and eventually, a reality check. By looking at the early days of the Dartmouth workshop, the boom of expert systems, and our current era of deep learning, we can get a better sense of how we got here and where we might be headed.

This talk takes a step back from the hype to explore the patterns that keep showing up in AI’s history. We'll see how technological, societal and geopolitical factors keep us falling into the same traps over and over when it comes to AI development. We'll look at technologies that felt cutting edge in their era, but which are now relegated to the history books. And we'll see what the legacy of previous AI summers has been, and what that might mean for today's AI era. AI’s history doesn’t repeat itself exactly, but it definitely rhymes.

Chances are that you’ve noticed that Python magically inserts “self” into methods for you. What you might not know is that the power behind this magic is the well-defined descriptor protocol. In fact, descriptors power many of the magical things in Python, from simple properties to lazy-loading attributes on database models.

In this talk, I will explain the magic of self by introducing you to the descriptor protocol. I will show you how this protocol powers the insertion of self and what else you can do with it. By the end, you will have a solid understanding of descriptors and know enough to start implementing descriptors of your own.

Let us build on examples from NumPy, pandas, and Matplotlib to explore techniques and tools with the Sphinx documentation generator. Learn how to implement styles, include advanced elements, and overcome challenges in creating clear, maintainable docs. 📑✨

Debugging microservices should not feel like detective work. When logs cannot tell the full story, it is time to embrace modern observability.

This session shows you how to collect metrics, logs, and traces from your Python applications using OpenTelemetry’s auto-instrumentation, then visualize everything in Grafana to quickly pinpoint performance issues and errors.

You will leave with practical skills to implement production-grade observability using open-source tools and open standards, with minimal code changes required.

Everyone is building "Chat with your data" applications, but moving them from a simple prototype to a secure, reliable enterprise-grade service is a monumental challenge. How does an agent navigate a labyrinth of hundreds of datasets to find the right one for a user's query? How does it integrate a growing ecosystem of specialized data tools alongside those datasets? And critically, how do you ensure it respects user permissions and interacts with other systems safely?

This talk presents a practical blueprint for building robust AI agents in a large enterprise environment. We will demonstrate a solution that allows users to chat with structured data to get answers, insights, and visualizations. Crucially, we will dive deep into the architecture that enables the agent to dynamically discover the most relevant datasets and tools for a given task, all while inheriting and restricting permissions based on the end-user's identity, preventing unauthorized data access. You will learn how to build a controllable, interoperable, and observable ecosystem of agents using standard protocols for dynamic tool discovery and governed communication.

Writing tests is an important part of every Django project. But Django’s default testing tools can be hard to use, slow, and not flexible enough. In this talk, I will show how to improve your tests using Pytest, Factory Boy, and Hypothesis.

We will start with Pytest, a simpler and more readable way to write tests. Then we’ll look at Factory Boy, which helps create test data more easily. Finally, we’ll explore Hypothesis, a tool that generates random test cases to help find hidden bugs.

You will leave this talk with clear examples and useful tips to write better tests in your Django projects using modern tools.

Your analysis works perfectly on your laptop. Three weeks later, it breaks on the server. Your colleague can't run your code nor reproduce your results. The client's environment throws mysterious errors. Sound familiar?

This hands-on workshop teaches you to build modern reproducible workflows using a holistic framework that addresses real challenges teams face when sharing code, collaborating on research, or deploying data pipelines.

You'll gain practical experience on:
* Modern tooling to manage Python environments and dependencies
* Version control your code and data
* Use configuration files to store your parameters
* Containerize your application for easy deployment
* Best practices for team collaboration

The workshop is ideal for data scientists, researchers, and Python developers with intermediate experience who are tired of "works on my machine" syndrome. You’ll gain hands-on experience with modern tools and practices that make Python workflows reproducible, maintainable, and easy to share, all while applying them to simply data science tasks.

DSPy is a declarative framework for building modular AI software. It allows you to iterate fast on structured code, rather than brittle strings, and offers algorithms that compile AI programs into effective prompts and weights for your language models, whether you're building simple classifiers, sophisticated RAG pipelines, or Agent loops.

Instead of wrangling prompts or training jobs, DSPy (Declarative Self-improving Python) enables you to build AI software from natural-language modules and to generically compose them with different models, inference strategies, or learning algorithms. This makes AI software more reliable, maintainable, and portable across models and strategies.

What if you could look into a magical mirror and see your deepest desires, generated by Python and AI? In this talk, we’ll build Harry Potter's Mirror of Erised using LLMs and text-to-image models to visualize personal dreams.

Testing is evolving beyond static test scripts into intelligent, adaptive systems. This workshop introduces participants to AI-powered QA pipelines built with Python, leveraging multi-agent architectures, machine learning, and Retrieval-Augmented Generation (RAG). Through hands-on coding, we’ll explore how to build automation frameworks that detect bugs intelligently, adapt to application changes, and scale across CI/CD workflows. Participants will leave with practical skills to design next-generation QA solutions using tools like PyTest, Selenium, LangChain, and scikit-learn.

Most Python teams already run PostgreSQL—but when it comes to background jobs, they often add Redis, RabbitMQ, or Celery on top. pgqueuer takes a different approach: it turns Postgres itself into a complete task queue.

At its core, pgqueuer uses simple tables to capture jobs and their metadata. Workers safely lease jobs with FOR UPDATE SKIP LOCKED, a Postgres feature that enables concurrent consumers without collisions. Idle workers wake instantly on new jobs via LISTEN/NOTIFY, while a fallback polling loop ensures progress even if notifications are lost.

On top of this foundation, pgqueuer adds the pieces needed in production: exactly-once dequeueing, heartbeats and cancellation for long-running tasks, and retry semantics for failure recovery. A built-in CLI dashboard provides live insight into throughput, latency, and error counts—no extra services required.

This talk walks through pgqueuer’s design and shows how PostgreSQL features can form a reliable, observable job system. Attendees will leave with a understanding of how to run production-ready background jobs directly on the database they already trust.

What if your database could run Python code inside SQL? In this talk, we’ll explore how to extend popular databases using Python, without needing to write a line of C.

We’ll cover three systems—SQLite, DuckDB, and PostgreSQL—and show how Python can be used in each to build custom SQL functions, accelerate data workflows, and prototype analytical logic. Each database offers a unique integration path:
- SQLite and DuckDB allow you to register Python functions directly into SQL via sqlite3.create_function, making it easy to inject business logic or custom transformations.
- PostgreSQL offers PL/Python, a full-featured procedural language for writing SQL functions in Python. We’ll also touch on advanced use cases, including embedding the Python interpreter directly into a PostgreSQL extension for deeper integration.

By the end of this talk, you’ll understand the capabilities, limitations, and gotchas of Python-powered extensions in each system—and how to choose the right tool depending on your use case, whether you’re analyzing data, building pipelines, or hacking on your own database.

Exceptions are often treated as an afterthought—until logs fill with cryptic stack traces and developers resort to except Exception: everywhere. In this talk, we’ll treat exceptions as a first-class API surface.

I’ll show how to design a clear exception hierarchy that distinguishes between user/validation errors, infrastructure failures, and unexpected bugs. We’ll explore how to define a lightweight interface (e.g. a status_code and optional metadata) so exceptions become predictable and machine-readable. Finally, we’ll see how stable domain error codes (like app.form.create.invalid_image_input) unlock better logging, monitoring, and user feedback.

Attendees will leave with a practical pattern they can apply to any Python project—web service, CLI, or library. This isn’t just about catching errors: it’s about designing recoverable, observable, and maintainable systems where exceptions aren’t noise but meaningful signals.

Sometimes the best things in life happen by accident. You think you’re just tinkering with code, and suddenly, you’ve stumbled into a path you never planned on. In my case, that path somehow led from late-night coding sessions for university to becoming a CPython core developer. But I didn’t get there alone.

This is a story about the Python community, the mentors, friends, and random emails that nudged me forward at just the right times. From navigating university to that one message that completely changed my direction, every step had someone in the community being there and encouraging me.

We’ll explore what contributing to Python actually teaches you - the technical lessons, sure, but also the more surprising non-technical ones.

Ultimately, it is a story about how communities can catch people at just the right moment, and how each of us has the power to be that pivotal person for someone else. Because in the end, the real magic of open source isn't in the code we write, it's in the friendships we make, and all the unexpected fun that comes with them.

Clasing Remarks Day 1

I have not built packages with millions of downloads. I haven’t contributed to CPython or shipped massive production projects. I am not a CEO, CTO, founder, or member of any tech board or committee.

Does that make this a “fraud” keynote? Maybe. Or maybe it’s an exploration of the uniquely valuable, often underestimated ways we can contribute to tech.

In this talk, I’ll share my journey with Python, the Elastic community, and the wider tech ecosystem. Together, we’ll explore:
* Finding a unique perspective or niche in tech, and owning it
* How curiosity, experimentation, and play can be great tools for learning.
* Imposter syndrome, overachieving, burnout, and aiming for the “slope of enlightenment” (and even the “plateau of sustainability”) over polished perfection.
* Ways to contribute meaningfully to your community, inspire others, and create impact.

Expect some career journey highlights and lessons earned, a few demo snippets of unconventional python projects (like Spotify and Harry Potter?), and some perspective on priorities vs inner peace.

Most AI agent tutorials end with a working demo, but production systems require fundamentally different design patterns. This hands-on workshop teaches the 4Ds framework for building AI agents that actually scale: Distributed, mostly Deterministic, Durable, and Debuggable.

You'll start by running a typical "demo-ware" document classifier that breaks under real-world conditions—rate limits, network failures, memory constraints, and concurrent requests. Then we'll systematically rebuild it using production patterns.

Distributed: Decompose AI workflows into parallelizable units using Hatchet's task orchestration. Transform sequential document processing into concurrent operations that scale horizontally.

mostly Deterministic: Constrain LLM outputs using Pydantic schemas and structured prompts. Build predictable fallback mechanisms for low-confidence results, turning non-deterministic AI into reliable system components.

Durable: Implement automatic retry logic and stateful checkpoints that survive failures without losing progress. Your workflows recover gracefully from API timeouts, service restarts, and infrastructure issues.

Debuggable: Add comprehensive observability through structured logging, distributed tracing, and real-time metrics. Watch your AI agents execute with full visibility into performance bottlenecks and failure patterns.

Each principle builds on practical Python code you'll run locally against cloud infrastructure. By the workshop's end, you'll have a complete production-ready document classification system processing hundreds of documents in parallel, with automatic recovery and full observability.

This is an infrastructure-focused training for Python developers who need to deploy AI agents that actually work in production. You'll leave with patterns immediately applicable to context/RAG systems, document processing pipelines, and multi-step AI workflows.

Prerequisites: Python 3.11+, basic asyncio knowledge, laptop with internet access.

Geospatial research projects often involve large, complex datasets, and the analysis frequently needs to be repeated, which can be time-consuming and error-prone. This makes automation, reproducibility, and scalability essential. Traditional Geographic Information System (GIS) software provides tools to support automation, but they can be difficult to maintain, hard to share, challenging to learn, not always free, and difficult to integrate with other data systems.

While many GIS platforms (e.g., ArcGIS and QGIS) include Python scripting, using Python standalone allows combining different libraries and methodological approaches, developing web-based GIS applications, and creating workflows that are efficient, flexible, and capable of handling hundreds of spatial data formats.

Packages such as GeoPandas, Shapely, Rasterio, and GDAL replace manual GIS steps with clear, scriptable workflows. These workflows can be version-controlled, parameterized, and shared across projects or organizations. Python allows geospatial specialists not only to automate tasks like data cleaning and map-making, but also to integrate spatial analysis with areas such as machine learning, web applications, and cloud platforms.

This work includes examples from real projects, such as cleaning shapefiles, fixing projections, and comparing multiple layers of data. While these tasks can also be performed using traditional GIS software, using the appropriate Python libraries provides faster, more reliable, and more reproducible solutions.

Quantum computing is moving from theory to practice—and Python is at the center of this shift. In this talk, we’ll explore Qiskit, open-source quantum SDK, and show how Python developers can already start shaping the future of computing. You’ll learn what quantum computing is, where it stands today, and why it matters for the Python community.

In 2007, when Python 2.5 was new and the first iPhone hadn't yet reached Sweden, Pymunk was born! Now, 18 years later, it has officially come of age. This is the story about the 2D physics library Pymunk, told by its creator.

With Pymunk's creation and evolution as a backdrop, I will share my thoughts and insights into maintaining a mildly successful open source library long term. We will explore a history that includes PyWeek-winning games, 100+ research papers on everything from COVID-19 to moral philosophy and mypy bugs.

And don't worry, you don't need to know the GJK collision algorithm, or even Newton's laws of motion, to follow along!

TBD

This workshop covers the basics of building applications with a microservice architecture. You'll learn how services communicate using message brokers and how to implement this with LavinMQ and AMQP. Through hands-on exercises, you'll gain practical experience in designing scalable, decoupled systems that handle real-world messaging patterns. Perfect for anyone looking to get started or refine their approach to microservices.

Python’s Global Interpreter Lock (GIL) is often portrayed as a limitation but it doesn’t have to be a blocker. In this talk, we will discuss the core concepts behind Python concurrency and explore practical ways to work with GIL rather than working against it. From threading to multiprocessing, async IO to real-world patterns, we will break down what’s really going on under the hood and when to use which approach.

Whether you are building data pipelines, web backends, or automating workflows, understanding concurrency is key to writing responsive and efficient Python code. I will use simple examples and real life scenarios to show how concurrency works in modern Python and share some hard earned lessons from debugging slow, blocking code in production systems.

What if you could see your users’ journeys—not as charts and funnels, but as characters navigating a world?
In this talk, we’ll use real user behavior data, combined with Pygame, spring simulations, and particle systems, to bring those journeys to life—turning abstract clickstreams into a gamified, interactive experience.

Python seems like a perfect first language to learn. It’s readable. It’s almost English. There are things that you learn to appreciate and cherish.
And there are other things that make you a little bit annoyed… Or sometimes cry out loud.
Let’s discuss!

Most of the applications are being powered by Generative AI. Some of the key proponents of Generative AI stem from concepts like RAG, Vector search and embeddings. This tutorial covers these core concepts on Vector search and is complete guide to help guide you from 0 to 1 in Vector Search with open source tools, libraries in Python understanding not only the core meaning of these terms but also hands on projects.

A special focus of this tutorial is to also learn how to build privacy focused applications. A lot of times user send data to LLM cloud providers like OpenAI, raising privacy concerns. This tutorial will also emphasise on an alternative and privacy focused way to build AI applications by running LLMs locally with Ollama that keep everything local on your computer. This approach allows to avoid sending sensitive information to external servers. The tutorial also highlights LangChain's ability to create versatile AI agents capable of handling tasks autonomously by creating embeddings for the data. So come learn how can you build the next gen, privacy focused Vector search application powered by Local LLMs, open source vector databases while learning the key concepts of Generative AI such as Vector search, embeddings and practical use cases with an end to end example.

TBD

Testing modern web applications often means dealing with sessions, cookies, and other stateful data, especially when testing login flows, e-commerce behavior, or personalization features. Traditionally, Selenium-based tests have handled this by spinning up a new browser instance per test. This ensures isolation, but at a significant cost: high memory usage, long startup times, and slower test runs.

What if you could maintain that isolation but with a single browser instance?

In this talk, I’ll walk through how the new WebDriver BiDi (Bidirectional Protocol) enables just that using user contexts to create isolated sessions (tabs) within one browser instance. We'll explore how to write Python tests that take advantage of this, reduce resource usage, and even scale more effectively in CI/CD or containerized environments like Kubernetes.

Whether you're running local tests or using Selenium Grid on the cloud, you'll leave this session with practical techniques to modernize your test setup without compromising on reliability.

Python is gaining ground in AI - it is now the language of both AI engineering and the language of agents. But is it losing ground as the language of programmers? Python made its name as the programming language that minimizes the impedance mismatch with natural language. However, with coding agents, it is now possible to go from natural language to working Python code. Where do we go from here?

I will place the evolution of coding agents in the history of programming language development. We will see that LLMs are more than just compilers that translate natural language into programs. I will also talk about the return of the waterfall lifecycle development process.

I will also talk about the effect of agents on developers. How are coding agents being received by developers? I will talk about three types of developers: those who supercharge their coding with agents, those who feel threatened by them, and those who weren’t developers but now are developers.

Finally, I will talk about developing agents. From model context protocol to application context protocol. Building AI systems has never been easier or more fun.

TBD

Clasing Remarks Day 2