Opening of PyCon Greece 2025! 🎉

Laís Carvalho blends observability expertise with Open Source and a passion for community-building. Former board member (EuroPython, Python Ireland), forever mentor, and advocate for inclusive tech. When not untangling distributed systems, she’s probably playing with watercolor brushes—proof that creativity and logic aren’t mutually exclusive.

As AI assistants become more capable, there's growing interest in enabling them to interact directly with cloud infrastructure. This talk demonstrates a practical implementation that connects Claude Desktop to the AWS Python SDK through Anthropic's Model Context Protocol, creating an intuitive, conversational interface for AWS resource management.

Why Humble Data?

There are many reasons for people to push aside their hopes of a tech career, we’re here to listen, to understand what makes it difficult and to lower that threshold bit by bit. It’s daunting to enter a world of seemingly full of professionals who are already skilled, who have already proven their competence. We want to show our participants that there’s more than meets the eye.

There’s a generosity that needs to be promoted more, we’ve seen that directly from the conference partners we collaborate with and the mentors giving their time to welcome people into this community. We’re here to spread that message and let people know that better diversity and inclusivity in tech can happen if we organise our efforts in the right way.

And what better way to do this than to start using data well? Use data in a way that represents all of us. Use data for good, follow best practices, and educate everyone how powerful it can be in the right hands. We can all make a difference by understanding data and even more when we can work with it. Which is why we should stay humble around data.

From Python’s new type parameter syntax and exception groups to structural pattern matching and assignment expressions, these are only a few of Python’s multitude of syntax features that all of us can use to make our lives easier.

But have you ever thought about what it takes to implement these features? How does your source code get transformed, so that Python knows what to do in order to produce the output that you expect (or not)? The tokenizer, the parser, the bytecode compiler and the interpreter are all pieces to the puzzle of how Python does its magic.

In this talk, we’ll look behind Python’s curtains and try to understand together how the CPython implementation takes in your source code, generates a token stream, creates from it an Abstract Syntax Tree, emits bytecode and finally interprets that bytecode to run your programs. And who knows? Maybe you’ll get to hear about some new and shiny syntax features as well!

In this talk, I’ll share how I used ChatGPT and Google Colab to prototype a Python-based solution that addressed a real business need—without writing all the code myself.

The challenge: extracting insights from over 90 hours of video feedback from customers. Manually analyzing this data was out of the question, and existing tools weren’t flexible enough. I’ll walk through how I broke the problem into smaller components and used ChatGPT as a collaborative coding partner to iteratively build and test a working solution.

Lessons Learned: Reflections on using LLMs for Python prototyping from the perspective of a non-developer: what they make easier, what they don’t, and where human judgment is still essential.

Have you ever wondered what happens behind the scenes when you use import in Python? In this talk, we will demystify Python's import system and explore best practices for managing imports. Moreover, we will discuss how your importing strategy impacts project architecture, influencing modularity and maintainability. For developers working on large Python projects, consistent importing is crucial. It helps maintain codebases by reducing complexity and avoiding technical debt.

The session will begin with an introduction to Python's modular structure: what modules and packages are, how sys.path influences imports, and what happens during the import process. We will also cover the importance of naming conventions and the difference between executing scripts and modules. Some of the things explained in this part may surprise you.

Next, we'll dive into various importing strategies and their implications. From absolute versus relative imports to lazy imports, wildcard imports, and typing-specific imports, we’ll clarify how to choose the right approach for maintainable and readable code.

The session will then explore how your importing structure affects the overall architecture of your project. We’ll address challenges like circular dependencies, separation of concerns, and the role of a layered architecture in maintaining flexibility and scalability.

Finally, we'll look at tools and techniques to enforce consistent importing practices. Learn how to integrate tools like Import Linter and Ruff into your CI pipeline to ensure adherence to your chosen strategy and avoid common pitfalls.

Whether you are a beginner or an experienced Python developer, this talk will help you streamline imports. You will learn practical strategies and tools to enforce consistency, making your projects easier to scale and manage.

AI-driven content and dynamic interfaces are reshaping the web, but accessibility often gets left behind. In this talk, I'll dive into real-world (and often hilarious) examples of AI accessibility fails, then explore how Python tools like axe-core, Playwright, TensorFlow, Pillow, and Django-Axe can help close the gap. Attendees will learn how to automate accessibility testing, generate smarter alt text, and improve UI navigation for all users. Through live demos and practical tips, I’ll show you how to integrate accessibility into your development workflow and avoid common pitfalls. Make your AI smarter and more inclusive!

The operating room is coding its way into the future, and Python is the language of change. Explore how Python's versatility is driving innovation in MedTech and transforming the landscape of medical robotics, bringing exciting implications for procedures like bronchoscopy. We'll explore how Python's robust ecosystem – with powerful libraries like OpenCV and TensorFlow/PyTorch – is enabling the development of cutting-edge solutions for minimally invasive interventions, pushing the boundaries of what's possible in healthcare.

Get ready to witness the algorithmic ingenuity behind robotic systems that achieve unprecedented surgical accuracy, paving the way for improved patient outcomes. Key topics will include the application of 3D Convolutional Neural Networks (CNNs) for advanced medical imaging, predictive maintenance to ensure the reliability of these complex systems, and real-time telemetry that empowers surgeons with enhanced control and precision. This session is not just about automation; it's about how Python is offering a 'cut above' traditional methods, leading to less invasive procedures and faster recovery times.

In a world increasingly driven by complex machine learning models, the simplest solutions can often be the most effective in solving real-world challenges. In this talk, I will share the journey of developing a pressure progression prediction model in Python to forecast the ripeness of avocados. This model helps to optimize the supply chain and contributes to sustainability by reducing food waste. Using Python libraries such as pandas, numpy, statsmodels, and plotly, the model is continuously refined to improve accuracy and provide actionable insights.

The avocado and fruit industry in the Netherlands, like many other markets, faces the challenge of managing perishable goods. The constant pressure to deliver fresh, high-quality products without waste makes predictive modeling a powerful tool for optimizing inventory and reducing losses. Ripewise (https://ripewise.com/), a product of Experience Fruit Quality (https://experiencefruitquality.nl/), leverages this approach to predict avocado ripeness, enhancing inventory management and offering a more sustainable solution to an industry-wide problem.

After attending this talk, the audience will learn how to apply machine learning techniques using simple, effective Python tools. Whether someone is a beginner or have some experience with Python, they will gain valuable insights into data preprocessing, model development, and result interpretation. Most importantly, the audience will adopt a mindset for creating practical predictive models, understanding that sometimes a simpler model is the best fit. By the end of the session, the audience will be equipped to tackle similar challenges with greater confidence and efficiency.

What happens when you stop storing the current state and start storing every change instead?

In this talk, we’ll explore how to build Python systems that are audited by design, event-driven at the core, and designed around CQRS and event sourcing. Using FastAPI, Celery, and a few familiar cloud tools, we’ll follow the evolution of a real-world architecture that treats raw events as first-class citizens.

We’ll dive into the fundamental questions:
• How do you model the world as a sequence of immutable events?
• What does it mean to replay the past—and why would you want to?
• Can you build a system that has no “current state,” and still serve fast, reliable queries?
• How do you scale such a system? Can it be consistent… eventually?
• How do you handle failures, race conditions, and fixes in a world where data isn’t just stored—it’s remembered?
• What does debugging look like when nothing is overwritten, and history is always available?

We’ll also touch on key design patterns—separating command from query logic, modularizing business rules with services and repositories, and how Celery can power a resilient pipeline for processing and projecting events.

You’ll leave with a deeper appreciation for the power of raw events, an understanding of what it means to treat event sourcing as a design philosophy, and a toolkit of questions to challenge the way you build your next Python backend.

Why Humble Data?

There are many reasons for people to push aside their hopes of a tech career, we’re here to listen, to understand what makes it difficult and to lower that threshold bit by bit. It’s daunting to enter a world of seemingly full of professionals who are already skilled, who have already proven their competence. We want to show our participants that there’s more than meets the eye.

There’s a generosity that needs to be promoted more, we’ve seen that directly from the conference partners we collaborate with and the mentors giving their time to welcome people into this community. We’re here to spread that message and let people know that better diversity and inclusivity in tech can happen if we organise our efforts in the right way.

And what better way to do this than to start using data well? Use data in a way that represents all of us. Use data for good, follow best practices, and educate everyone how powerful it can be in the right hands. We can all make a difference by understanding data and even more when we can work with it. Which is why we should stay humble around data.

In programming we painstakingly obsess about finding good abstractions and not repeating ourselves. But what do we lose in that process and is there something to be gained from consciously and actively repeating your work?

In this talk I will share multiple rewrites of a music synthesizer written in Python; through that lens I will demonstrate the incredible value of repeating yourself and being "inefficient"

Sponsored talk by Elastic.

Python's remarkable growth over the decades can be attributed largely to its adaptability, a continuous effort which is centered around the Python Enhancement Proposal (PEP) process. PEPs act as a formal mechanism through which new features are added to Python. This talk explores the lifecycle of PEPs and their history, as well as their importance for Python's continuous development and how the community can participate.

We'll begin by reviewing what PEPs are, the roles of key contributors, and how proposals transition from draft to implementation. Historical highlights such as PEP 484 (Type Hints) will showcase how they enhance developer productivity and Python's robustness. Audience members will gain insights into the critical role of community collaboration in the PEP process and practical tips for participating.

By examining the role of PEPs in Python's future, this session aims to inspire attendees to actively engage with the Python ecosystem and its development. Whether you're a seasoned developer or a curious learner, this talk promises a fascinating look at the heartbeat of Python's evolutionary process.

I'm a research engineer working at Cloudflare and in my work we need to measure various aspects of the Internet, such as the Internet topology (how ISPs are interconnected), performance of end-to-end paths, and security risks of the routing system. To collect such measurements, we rely on various open-source python tools that are less known but enable large-scale measurements of real-time Internet phenomena. In this talk I will first introduce briefly some core Internet networking aspects, why engineers and researchers want to measure and monitor them and then I will walk you through a suite of open-source Python tools we use in Cloudflare to probe, map and analyze macroscopic properties of the Internet ecosystem. My aim is for attendees to walk away with some fundamentals on networking and concrete, reusable examples on how to build their own Python-powered Internet measurement pipelines.

Description

In this workshop we'll explore the Julia programming language and get a first-hand look at how it can play nicely with your Python code! We'll discover how easy it is to seamlessly blend Julia calls with Python programs, to deliver performance gains while accessing cutting-edge scientific computing libraries.

Intended Audience

Intermediate: Familiarity with the Python programming language and mathematical modeling

Learning Outcomes

By the end of this workshop, you will:
- Understand when Julia+Python offers significant advantages over pure Python solutions
- Be able to call Julia packages from existing Python code using practical examples
- Know how to evaluate and integrate tools like ModelingToolkit.jl, diffeqpy, and PySR into your projects
- Have a clear path for continued learning and implementation in your work

Structure

• 10 minutes: Introduction to the Julia programming language
• 10 minutes: Overview of Python + Julia interop
• 30 minutes: Live coding demonstrations, using Julia packages from Python code
• 10 minutes: Q&A

Speaker Experience

We're organizers of the Greek Julia community! Panagiotis works at JuliaHub developing modeling and simulation tools in Julia, with previous experience at the Intelligencia startup and OPAP, focusing on data analysis and application development. Orestis develops tools and mathematical models for space missions using Julia at EMTECH SPACE S.A. and at a stealth startup.
Prerequisites: For the workshop to run smoothly, attendees are encouraged to already have Python and Julia (https://julialang.org/install) installed.

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.

Python has become the dominant language in scientific computing—even in domains that demand high performance. This is largely due to the power of array-oriented programming, which separates complex problems into two parts: lightweight bookkeeping and heavy numerical computation. The latter is handled efficiently by vectorized operations that rely on fast, precompiled libraries.

This tutorial introduces array-oriented programming as a distinct mindset that encourages new ways of structuring problems. Rather than focusing on any one library, we’ll cover general techniques that apply across ecosystems like NumPy, Pandas, xarray, CuPy, and Awkward Array.

Array-oriented programming has its roots in languages like APL and remains central to scientific data analysis and simulation today. This session is designed to deepen your understanding of the paradigm and improve your ability to write efficient, expressive scientific code.

The success of open source projects doesn’t solely rest on technical brilliance—it’s deeply rooted in culture. "Culture eats strategy for breakfast," a timeless phrase, underscores how even the most meticulously planned strategies will falter in an environment lacking trust, respect, and inclusivity.
Psychological safety is the foundation of a strong culture in open source, where developers often work publicly and collaboratively. This talk highlights how projects like Django have embraced inclusive cultural practices, ensuring contributors feel safe and valued, focusing on DSF Working Groups and the success of Djangonaut Space.

In this talk, I ‘ll share how a simple LinkedIn post about contributing to the Greek Python documentation unexpectedly set me on a path to becoming the project’s main contributor/ maintainer and a core community member of PyGreece and more.

What started with translating just a few files and some Pull Requests soon turned into a deeper involvement with the Open Source world, meaningful collaborations, and an active role in shaping the Python community in Greece. Through this personal journey, I will highlight how small contributions, even ones that seem minor, can lead to big changes, new opportunities, and lasting impact.

The talk is structured in three sections:

• A look into the Python Docs Gr translation project, its purpose, structure and the challenges we’ve faced.
• A small - practical walkthrough on how anyone can contribute to an Open Source Project, even without advanced technical skills..
• My personal story; how I started, how I became a maintainer, and how this journey led to deep community bonds and so much more.

This is a talk for the curious and the bold, for those who want to start “doing things” but don’t know where to begin. My hope is to inspire attendees to get involved in open source, take initiatives, and discover where even the smallest step might lead them. All you really need is curiosity, willingness to learn, and a little bit of courage.

The world around us is full of information of many types, and although many of us communicate verbally, we often lose information about context or intent if it's not accompanied by images. The same thing happens with models when we try to solve very complex problems with models that can only contain information of a specific type. For this reason, solutions that can integrate different types of data, such as images, text, video, or audio, are needed: multimodal models. These systems combine multiple inputs of different data types and make systems more robust, helping in areas such as health, security, criminology, business, and more.

The objective of this talk is to show how to create a system capable of identifying emotions from various types of images and, in parallel, extracting emotions from texts using that result to get a more global understanding of the scene emotion (a system without GenAI and another with GenAI).

In this talk, attendees will learn step-by-step how to implement a multimodal system that includes images and text, using open-access data, and understand how multimodal systems are a good option for solving complex problems. In addition, the role of Python in the process will be shared, as well as the application of external modules for a simple implementation, to facilitate the multimodal process.

Important:
General knowledge of Data Science is recommended to follow the topic easily, although the explanation will be simplified, going through all the necessary steps to understand how it is done.

How can we design smarter learning systems that respond to learners’ individual goals and backgrounds?

In this talk, I’ll share how I built a lightweight yet effective personalized course recommendation engine for an e-learning platform using unsupervised learning. Starting with real questionnaire submissions from users interested in Data Analytics, I applied clustering to segment learners by intent, experience, and pain points. Based on these segments, I matched them with curated learning paths from a library of course offerings. The whole system is build using Python and related libraries.

This isn’t a deep-learning black box. It’s a lean, explainable approach that uses scikit-learn pipelines and KMeans clustering to bridge user intent with actionable content. The result? A system that adapts to each learner and scales with minimal manual effort.

This talk will walk the audience through:

1) The challenge of personalization in learning platforms,
2) How clustering can help reveal patterns in learner behavior,
3) Lessons learned building for real users on a live platform.

By the end, you’ll see how unsupervised learning, when thoughtfully design, can create scalable, human-centered experiences, especially in education.

5-minute lightning talks submitted on-site

Closing remarks for Day 1

Welcome back to Day 2 of PyCon Greece 2025!

Grigoris Maravelias is an astrophysicist passionate about massive stars, astronomy outreach, and the power of Python. After earning his PhD in 2014 (University of Crete), he held research posts in Czechia, Chile, and Greece. A machine learning advocate in astrophysics, he co-founded the Summer School for Astrostatistics and teaches Python at the University of Crete. He’s also deeply involved in science education through PeriAstron, blending starlight, code, and community to make science more accessible and impactful.

In this 60‑minute tutorial I will show you how to build a robust, scalable AI‑powered web service
by combining three cutting‑edge, open‑source technologies:

1.FastAPI for high‑performance asynchronous APIs

1. Pydantic‑AI for type‑safe, schema‑driven agent construction

2. Model Context Protocol (MCP) servers (from modelcontextprotocol/servers) as
   plug‑and‑play tools

You’ll learn advanced data modeling patterns, integrate multiple LLMs, and wire up an MCP
“Filesystem” tool so your AI agent can securely read real data at runtime. By the end, you’ll
have a production‑ready template you can extend with any MCP server (web search, database
access, GitHub, etc.) and confidently deploy in Docker in your Homelab or in Cloud.

Panel discussion with the organizers of PyCon Greece. Come hear the story of how the conference came together!

In a world of microservices, distributed systems, and ever-growing complexity, understanding what your Python applications are doing under the hood is no longer a luxury—it’s a necessity. This talk introduces OpenTelemetry, the CNCF project that is fast becoming the global standard for observability.

We’ll explore how to instrument Python applications with OpenTelemetry to capture traces, metrics, and logs, and how to export this data to popular backends like Prometheus, Jaeger, or Elastic. Whether you're building a Flask API or a machine learning pipeline, you'll leave this talk understanding how observability can help you debug faster, monitor better, and sleep easier. All these, relying on an open-source, community driven project without the fear of vendor lock-in.

We will wrap up the session with a live demo, putting into action OpenTelemetry + Python.

Curious how new AI agents emerge daily? Discover the fundamentals of AI agents and create one yourself using basic Python skills. This talk with a 7-step tutorial cuts through the complexity to show you how building an AI assistant is surprisingly easy nowadays - simpler than other pet projects you've built before.

We'll cover:
- Core principles of AI agent architecture
- Step-by-step tutorial using Agent Development Kit (ADK) framework and LangChain tools
- Demo where AI agent does complex Cloud operations on your behalf, like creating a Kubernetes cluster and sequencing it for the upgrade
- Practical customization techniques for different use cases

By the end, you'll have developed a functional AI agent for your needs to showcase in your portfolio.
Join me to demystify AI by building it yourself!

Building a Django app that works in multiple languages can seem difficult, but it doesn’t have to be. In this talk, you’ll learn how to make your Django apps multilingual using built-in tools and new AI-powered helpers. We’ll cover the basics of internationalization, show hidden features in Django, and introduce a tool that uses AI to help translate your app faster and more easily. Whether you're just starting or have experience with Django, you’ll leave with practical tips you can use right away.

I’ve been working as a backend developer for four years. In my current role, I work with large datasets—millions of rows and complex queries. Simple Django tips like select_related or caching are often not enough. In this talk, I will share real solutions I’ve used in production to improve performance using Django and PostgreSQL together.

As Django projects grow, performance issues start to appear. Queries slow down, pagination gets laggy, and advanced database features become necessary. This talk will focus on four advanced but practical techniques that help keep Django fast and clean—even with large amounts of data.

First, I’ll show how to use materialized views in PostgreSQL and how to connect them to Django models. They are great for speeding up heavy queries, especially in reports or analytics. I’ll explain how to create, refresh, and use them in Django without breaking the ORM.

Next, we’ll look at when using subqueries instead of DISTINCT can bring better performance. I’ll show clear examples comparing both approaches and explain when choosing subqueries might be more efficient.

Then, I’ll introduce the new GeneratedField feature from Django 5. This allows you to define fields whose values are automatically computed by the database based on other fields in the same model. Unlike properties or annotations, GeneratedField ensures that the computed value is stored and maintained at the database level, leading to improved performance and data consistency. I’ll explain how it works and share how we've started using it in our projects.

Finally, I’ll cover window functions, especially ROW_NUMBER(), and how to use them together with Django’s ORM tools like OuterRef and Subquery for smarter and faster queries.

This talk is for Django developers who already know the basics and want to go further—especially those working with big data and real-world performance problems. You’ll leave with ideas, patterns, and code you can start using right away.

It’s time for Day 2 Ops in the world of AI.

Building enterprise-ready AI poses challenges around data security, scalability, and integration, especially in compliance-regulated industries. Firms are increasing efforts to mitigate risks associated with LLMs regarding sensitive data exfiltration of PII and sensitive company data. The primary mitigation strategy is to build guardrails around Retrieval-Augmented Generation (RAG) to safeguard data while also optimizing query response efficiency.

This session will cover how modern permissions systems can safeguard sensitive data in RAG pipelines. We'll start with why Authorization is critical for RAG pipelines to protect sensitive data from potential vulnerabilities and also the various techniques for permissions-aware data retrieval including prefiltering, and post-filtering vector databases.

The talk will also include a practical demo implementing fine-grained authorization for RAG using Pinecone, Langchain, OpenAI, and SpiceDB.

PyLadies Lunch!

Pre-registration required.

Would you use a threshing machine to mow your lawn? Probably not — yet many data engineers reach for Spark to run ETL pipelines, even when it's overkill. In reality, most of us deal with data volumes that are large, but not that large — think gigabytes, not petabytes. Tools like DuckDB, Polars, and Dask are challenging the default assumption that “big data problems need big frameworks.”

This talk is for Python developers, data engineers, and analytics engineers who work with batch data pipelines and want to simplify their stack without sacrificing performance. We’ll explore a comparative benchmark of modern Python-native ETL tools, using a data model representative of real-life scenarios — including both historical and incremental loads — and test their performance on datasets ranging from “fits in RAM” to multiple gigabytes.

You’ll see real-world code examples of common ETL transformations, understand the upfront setup and ongoing maintenance each tool requires, and learn how to choose the right tool based on your workload and team skills. Whether you’re building out a data platform or just cleaning up CSVs, this talk will help you rethink ETL for the modern Python ecosystem.

The potential that Python has had since its origins, with its standard implementation written in C,
has been demonstrated by the language's evolution, focused on calculations with the performance and precision necessary to be part of scientific projects that are revolutionizing different fields.

But how do extensions work?
In this talk, we will look at how different programming languages offer the possibility of extending Python, and current cases to which its popularity can be attributed.

Practical examples of extensions in C++ and Rust will be presented, mentioning other examples such as Lua, Zig, among others. Additionally, the tools ("binding generators") that are currently available and are responsible for the development of many projects that you are probably using, perhaps without realizing it, will be presented.

After this talk you will learn how to create Python extensions in a few languages.

Description

Since its introduction, the use of pyproject.toml has expanded to hold more than project metadata and packaging configuration. It now serves as an entry point for working with Python codebases, which many tools like linters and style checkers rely on. However, many projects still use older setups with multiple configuration files, which are harder to manage, especially for newcomers.

In this tutorial, we will work with an existing codebase to show how pyproject.toml can be used for different goals, including setting up packaging, configuring linting, type checking, and testing.

Outcomes

After this tutorial, participants will be able to:
- Declare dependencies and set up command-line entry points for a package
- Explain the purpose of linters, formatters, and static type analyzers
- Install and use tools like flake8, mypy, and tox, as well as configure them through pyproject.toml

Format

After a brief introduction, this will be a hands-on workshop following written instructions for an existing codebase. Participants will have some freedom to focus on different aspects, depending on their experience level and interests (see Audience section). The expected time breakdown is 15% intro/explanations, 75% hands-on exercises, 10% Q&A.

Audience

This tutorial is mainly aimed at beginner and intermediate Python users. No knowledge of particular libraries is required beyond basic familiarity with Python. Participants who are familiar with the concepts and tools can focus on how to convert an existing set of configurations to pyproject.toml, while less experienced members will focus on the purpose of the different tools.

Speaker Experience

I have been involved in programming training for more than 7 years in both academia and industry. I have experience in developing and delivering lectures, workshops, and tutorials to audiences with varied experience levels and backgrounds. In my current role as an engineering trainer, I deliver courses on deeper Python topics, while also helping maintain a series of tools written in Python and other languages.

Why should you, as a Python developer, learn Rust? In this talk, we will explore Rust's compelling answers to this question. Rust offers guaranteed type safety and memory safety without a garbage collector, "fearless concurrency," and incredible performance. We will look into some of Rust's most distinctive features from a Python perspective, including its strict compiler, the ownership and borrowing system, null safety via Option<T>, and explicit mutability. We will discover how Rust eliminates common runtime errors at compile time, and additionally, how understanding the concepts behind Rust's safety features can sharpen your Python skills, helping to write more robust and reliable code. By the end of the talk, you'll understand Rust's core value proposition and how its paradigms can benefit you, whether you are writing Python, Rust, or any other language.

If you or your organization are spending time and resources attending a Python conference, you will want to ensure your team gets something immediately actionable and helpful out of it. As coders, we often think about writing code as the only way to contribute. However, pull request reviews are an often overlooked, but highly actionable way to have an impact.

Giving good PR reviews is an art, with two equally important parts: the technical side and the communication side. While the technical side ensures the quality, maintainability, and efficiency of the Python code, the communication around the PR determines whether the feedback can be understood and acted upon. However, we have all seen code reviews that have been ignored or executed poorly due to poor communication.

This talk addresses both facets of PR reviews by introducing the archetypes of bad code reviewers:
1. The “Looks Good to Me” Reviewer: This peer reviewer provides little to no actionable feedback.
2. The “Technical Nitpicker”: This peer reviewer focuses on small Python-specific issues, but fails to communicate constructively.
3. The “Nit” Commenter: This peer reviewer prefaces every comment with “nit,” while offering unclear, yet technically valid suggestions

Using these archetypes, we will explore Python-specific technical topics (such as pass by reference vs. pass by value), while delving into how to communicate and deliver feedback in a clear and actionable manner. Using real-world examples, attendees will learn how to:

a) Identify and address technical issues in Python PRs
b) Communicate feedback effectively
c) Balance technical rigor with constructive feedback
d) Communicate their peer review comments clearly

Sponsored talk by Yodeck

Asyncio has become one of Python’s most popular libraries for writing fast, scalable applications. But sometimes, using async can actually make programs slower.
In this talk, we’ll explore common mistakes while using asyncio, why misunderstanding the difference between I/O-bound and CPU-bound tasks leads to poor performance, and practical patterns for writing efficient async code.
Through real-world examples and live demos, you’ll leave with a clear model for using asyncio effectively.

One of the challenges for a machine learning project is to deploy it. Fast API provides a fast and easy way to deploy a prototype with less software development expertise and yet allow it to be developed into a professional web service. We will look at how to do it.

In this workshop, we will go deeper into how to prototype a machine-learning project with Fast API. Fast API allows the creation API server with very little effort, it is easy to deploy a pre-trained model, but for models that require re-training, the challenge of when and how to retrain a model and update for a service in use becomes complicated. We will cover the aspect of delivering a pre-trained model and the design of re-training the model. This workshop will also provide suggestions for deploying the machine learning project so it can migrate from a prototype to a functional service in production.

Goal

The workshop aims to equip a data science team capability to convert their machine learning project into a prototype service using Fast API, at the end of the workshop, they will not just be able to deliver API calls to a pre-trained model, but they will also be able to design when to re-train and update the model and be ready to migrate the prototype into production.

Target audience

Data scientists who have little or no experience using Fast API or putting a machine learning model into production. This workshop will assume the audience already knows how to build and train a basic machine learning model (e.g. using Sci-kit learn).

Outline

Part 1 - Introduction to Fast APi and prediction on demand

• Understand the basics of Fast API
• Using a pre-trained model for prediction with API calls
• Validating the query parameters

Part 2 - Re-train and update models

• Problem with updating model: Race conditions
• Scheduled re-training
• Re-training on demand with Fast API

Part 3 - Machine learning model in production

• Fast API in docker containers
• Fast API on the cloud

Smart agents are a powerful tool that has recently gained popularity by introducing revolutionary features to existing applications. LangChain offers a flexible framework for building intelligent AI agents with minimal effort, allowing seamless integration with LLMs such as ChatGPT and Claude. In this talk, we highlight the extreme capabilities of LangChain agents—from answering domain-specific questions using RAG to performing predefined actions through function calling. Finally, it would be presented a real-world use case where LangChain agents are applied in a research project to deliver insights about a Kubernetes-based cluster directly to end users.

We've all done it-written tests full of mocks that pass, but don't really prove anything.
Mocking is powerful, but using the wrong kind of mock (or mocking the wrong thing) leads to fragile tests and false confidence. Over-reliance on mocks can obscure a system's behaviour, making tests more flaky while hiding integration issues with other services. This talk is about using mocking intentionally, with a
clear purpose behind each approach,

I'll break down four common patterns:

• Pure mocks for verifying behaviour

• Stubs to simulate simple responses

• Spies to track how something was used, without taking full control

• Fakes to produce minimal but working versions of real systems like in-memory APIs
  or fake databases

Along the way, we'll explore how to implement these strategies using Python's most
popular testing frameworks. Whether you're testing micro-services, APIs, or just trying to write more trustworthy unit tests, this talk will help you choose the right approach for the job and avoid common pitfalls.

If you've ever wondered "am I mocking too much?" or "why does this test feel flaky even
though it passes?", this talk is for you. You'll walk away with better instincts for testing real-
world systems and a few solid patterns to keep your test suite fast, clear, and reliable.

Ever wondered how dating apps decide who shows up on your feed? Whether it’s Tinder, Bumble, or Hinge, these platforms use a mix of algorithms and features to predict who you might click with - and who might click back.

In this talk, we’ll explore how recommender systems form the heart of modern dating apps. You’ll learn:
• How different apps approach matching
• What makes dating recommendations different from, say, Netflix suggestions
• Why graph-based models are a natural fit for social interactions
• The human side: balancing algorithmic relevance with diversity and fairness

No prior experience with machine learning is needed. Together we’ll tackle the key concepts with real-world examples, visuals, and stories from building recommenders in practice. Come for the algorithms, stay for the love stories.

Pablo Galindo Salgado works in the Python Infrastructure team at the Software Infrastructure department at Bloomberg L.P. He is a CPython core developer and a Theoretical Physicist specializing in general relativity and black hole physics. He is currently serving on the Python Steering Council for the fifth year and he is the release manager for Python 3.10 and 3.11. He also has a cat who doesn’t code.

Closing remarks for PyCon GR 2025 🥹