EuroPython 2022

EuroPython 2022 Opening Session [The Auditorium on 2022-07-13] Welcome to EuroPython 2022! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Keynote: Python's role in unlocking the secrets of the Universe with the James Webb Space Telescope - presented by Dr. Patrick Kavanagh [The Auditorium on 2022-07-13] The James Webb Space Telescope is a groundbreaking infrared observatory resulting from an international collaboration between NASA, the European Space Agency, and the Canadian Space Agency. It was successfully launched on Christmas Day 2021 from Europe's spaceport in Kourou, French Guiana, and is currently orbiting the L2 point 1.5 million km from Earth. Webb was designed to address some of the biggest questions in astronomy and astrophysics, including identifying the first stars in the Universe, observing the first galaxies, revealing the initial stages of star and planet formation, and probing the composition of exoplanet atmospheres. But how do we go from the raw data collected by Webb to science-ready data products delivered to astronomers and astrophysicists around the world? How do we embed our understanding of the telescope and its instruments into this process? How did we prepare and test this? From instrument simulators to the ambitious Webb Calibration Pipeline, the software suites that support these tasks are written in Python. In this talk I will give an overview of Webb, the crucial role of Python in Webb's development and data processing, and I will show and discuss the first publicly released images from this revolutionary telescope. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Music and Code - presented by Nicholas H.Tollervey [The Auditorium on 2022-07-13] Learning to code requires a long term investment of time and effort to acquire a set of skills, theory, knowledge and experience in order to effectively make software. Learning to play an instrument requires a long term investment of time and effort to acquire a set of skills, theory, knowledge and experience in order to effectively make music. I will compare and contrast certain aspects of the worlds of code and music and will explore questions such as: what would music lessons look like if we taught music like we teach coding (and vice versa)? Who are the virtuoso coders we should celebrate as role models? (And why?) How do musicians and coders sustain AND develop their cultures across generations? Is coding an art? Is music a science? What could folks do to cultivate their practice of music and code? How can we tell if someone is an "expert", and should we trust their advice? Most of all, it'll be practical, fun and thoughtful. I hope to make a space for some interesting and stimulating ideas. Then we can all explore them together in the corridor track. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Choosing the right database for your next project - Looking at options beyond PostgreSQL and MySQL - presented by Marc-Andre Lemburg [Liffey Hall 1 on 2022-07-13] In the last few years, lots of new database engines have been developed and existing ones have been extended to cover new application spaces and features, making the selection process even more challenging than it was before, if you want to maintain an edge. The talk will highlight the most important database engines to consider and their strengths when using them with Python applications, covering relational databases for general purpose tasks, data warehouse workloads, data analytics, machine learning, streaming data and massive scalability, to name a few aspects. Talk slides: https://downloads.egenix.com/python/EuroPython-2022-Talk-Choosing-the-right-database-for-your-next-project.pdf This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - How to embed a Python interpreter in an iOS app - presented by Łukasz Langa [Liffey A on 2022-07-15] Come see how you can make a native mobile app that embeds Python 3.10 to allow users to script app behavior. It's allowed by Apple but is currently underutilized by the app makers. Add superpowers to your iPhone app with Python! Native mobile applications have many advantages over mobile websites or apps made with cross-platform toolkits. They will use less battery, allow for richer graphics, more consistent UI behavior, and enable more functionality through device-specific APIs. Wouldn't it be great to have access to all this from Python? In this talk, we'll marry a native iOS app written in Swift with an embedded Python 3.10 interpreter to allow users to customize what the application is doing. We'll go through the entire process of: - embedding Python from source; - building it into the Swift mobile app in Xcode; - adding a few pre-compiled third-party libraries like numpy and Pillow to broaden the scope of what the user can do; - running the resulting app on an iPhone 13; - modifying the app behavior at runtime thanks to our new Python superpowers! Knowledge of Swift is not required for attendees of this talk. However, it will be needed later if you're willing to embed Python in an iPhone app. Embedding Python doesn't really let you make an app without knowing Swift. Don't fret though! It's pretty easy to get a hang of Swift when you're fluent in Python. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - How much time does it take to write tests? A case study - presented by Antonis Christofides [Liffey Hall 2 on 2022-07-13] Writing automated tests takes time. As developers, we are constantly pressed by management to deliver early, which means we are tempted to skip writing some of the tests. Of course, in the long term, the time needed to write tests is paid off. But how much of our time do we spend in order to write tests? Is it half? Is it three-quarters? This can be difficult to measure, particularly if we are using test-driven development, because in that case writing tests is integrated in the process of writing code. While I like test-driven development, I can only practice it when I have a good idea of what code I want to write. But sometimes my idea of how to approach the problem at hand is quite vague and I experiment a lot. In these cases, I write the code first and the tests after that. In one such case I first finished the functionality I was developing and proclaimed it ""beta"". I then went on to write the unit tests for it. As a result, I have a clear idea how much time I spent writing documentation and main code, and how much I spent writing tests. In this talk I examine the implications of all this." This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Property-based testing the Python way - presented by Emma Saroyan [Liffey Hall 2 on 2022-07-13] This is an introductory talk about property-based testing. The talk requires some previous knowledge about testing to make the most out of it but if you are new and curious I think you would get something out of it. The talk approaches a simple problem from two different testing perspectives. Giving you an idea about property-based testing and how it’s different from the traditional approach with Python. The main focus of the topic would be Hypothesis and how you can achieve your testing goals with it. By the end of this talk you would have a solid understanding of property-based testing with Hypothesis, that would help you decide which testing approach fits your need. Given below is a rough overview of the talk structure: - The testing problem - This is where you would explain the problem statement - The traditional approach - Cons of traditional approach - What is property-based testing ? - Intro to Hypothesis - Same problem solution with Hypothesis - Why choose Hypothesis as a go-to property based testing tool ? - Parametrized testing with Pytest vs Hypothesis approach - When or when not to use property based testing - How can you adopt `hypothesis` in your code base ? Some opinions here." This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Dance with shadows: stubs, patch and mock - presented by María Andrea Vignau [Liffey Hall 2 on 2022-07-13] A comprehensive but simple introduction to the use of fake objects. Explain how to inject this object and use in test using patch and the awesome and powerful mock objects . Last, I present some very interesting specialized libraries for mocking on web development. Outline 0:00 I present the key factors to use fake objects, and present some dangers. 3:00 Discuss some wanted characteristics in this kind of components. 6:00 Patching: how to do that and some common mistakes. After that I present patch scopes and some disadvantage in the use of this technique. 10:00 Inverse dependency as an possible alternative to patch 13:00 Mocks properties: return value, side effect and specs. Using mocks as spy functions or wrappers. Asserting on callings. 21:00 Using special libraries for mocking. Presenting pyvcr and moto." This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - How to craft awesome Machine Learning demos with Python - presented by Omar Sanseviero [Liffey Hall 2 on 2022-07-13] Building interactive Machine Learning demos is now easier than ever. With Open Source libraries such as Gradio and Streamlit, you can use Python to craft demos, and use Spaces to share them with the rest of the ML ecosystem as well as non-ML people. Learning to create graphic interfaces for models is extremely useful for sharing with other people interesting in them. All of this leverages free, open-source tools that anyone can use." This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Applying machine learning capabilities to wearable IoT devices for boxing technique management - presented by Anthony I. Joseph [Liffey Hall 2 on 2022-07-13] Internet of Things (IoT) devices are becoming more advanced through additional sensors, reduced size and increased computational power. In particular, this increase in computational power allows one to run previously-trained machine learning algorithms natively on an IoT device. This presents an exciting opportunity: IoT devices often feature a variety of onboard sensors which can be used as inputs into a machine learning algorithm. This talk will use the presenter's boxing training as a practical example of applying sensor data to a machine learning algorithm. In particular, this talk will demonstrate using motion sensor data obtained on an Arduino Nano 33 BLE Sense configured with TensorFlow Lite. This talk will discuss the entire analytical process from problem and data analysis through to algorithm training and deployment. It will also discuss boxing concepts and how these concepts are modelled in an IoT context. The links to code are provided below: - https://github.com/ajosephau/boxing_tracker_nano_ble_sense - https://github.com/ajosephau/boxing_tracker_wio_terminal The slide deck is available here: - https://www.dropbox.com/s/7448hf8q9umnnse/Wearable%20Tech%20boxing%20technique.pdf?dl=0" This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - The beginner’s data science project checklist - presented by Sara Iris Garcia [Liffey Hall 2 on 2022-07-13] In this talk you will learn tips on: - Defining requirements - Outlining a data science project - Reproducibility and Readability checklist - Best practices for writing Documentation - Useful python tools - Tips on presenting your findings This is a talk is intended for beginner audience." This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - An Introduction to Apache TVM - presented by Leandro Nunes [Liffey Hall 2 on 2022-07-13] This talk will present an introduction to Apache TVM using its Python API, and will include a demonstration using examples of deep learning models being executed in CPUs and Microcontrollers. Apache TVM is a very flexible compilation stack for deep learning models, supporting many input formats such as TensorFlow, TFLite, Keras, PyTorch, ONNX, etc. as well as many target hardware like CPUs, GPUs and neural networks accelerators. This talk will present a walkthrough of TVM Python API from installation to usage, demonstrating its features using a series of quick practical projects. The high-level agenda is: - TVM in a nutshell (a brief description of what is TVM) - How to install - Introduction to TVM Python API - Practical demos: Compiling and tuning a model - Compiling and running a model on an embedded target - Final Remarks" This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Building a Just-in-Time Python FaaS Platform with Unikraft - presented by Felipe Huici, Alexander Jung [Liffey Hall 1 on 2022-07-13] Unikraft [1] is a unikernel (specialized virtual machine) project. Unikraft is able to target a specific application (e.g., a web server such as NGINX) and transparently build an entire software stack, from the operating system all the way up to systems libraries, that includes only the parts that the application needs and nothing more. Such specialization results in extremely short boot times (a few milliseconds compared to hundreds or thousands for Linux VMs), small image sizes and memory consumption (e.g., a few MBs vs. hundreds of MBs) and a minimal attack surface, to name a few benefits. The short boot times also allow us to bring Unikraft VMs up just-in-time, as a request for a service arrives, and to bring the instance back down (or suspend it) when the request is over, allowing for even greater efficiency. In addition, Unikraft images are single address space: in cloud environments strong isolation is provided by the hypervisor, so for single application/single tenant VMs it does not make sense to have a kernel/user-space divide. The end result is higher efficiency in performance, with Unikraft yielding noticeably higher throughout than Linux [2]. Regarding application support, we have put great effort towards making Unikraft as POSIX compatible as possible. Unikraft provides a syscall shim-layer and support for the musl libc, allowing us to run unmodified versions of Python. In terms of orchestration, we have integrated Unikraft with major frameworks such as Kubernetes and Prometheus. This, along with extensive debugging facilities should make Unikraft easy to both use and develop for. [1] https://unikraft.org/ [2] https://dl.acm.org/doi/10.1145/3447786.3456248 (best paper award) This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Making AI Happen at Your Company - presented by Alexander CS Hendorf [Liffey Hall 1 on 2022-07-13] Many incumbents are transitioning to new technologies while their businesses operate on systems that are years or decades old. Introducing new technologies is not just about introducing Open Source or introducing community culture or working agile or SCRUM or explaining the complicated technology stuff to executives. The truth is: it requires all of it and likely even more. Mastering innovation requires having many balls in the air at once. In this talk I’ll present a transformation use case of an established player including our best practices and anti-patterns. We will discuss the following aspects: * From idea to strategy * Assessing the status quo * Introducing Python and Open Source and what to use (or not) * Legacy is in the the house, still * Getting all departments on the same page * Introducing a community-driven collaborative culture This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Classifying LEGO Bricks with Machine Learning - presented by Piotr Rybak [Liffey Hall 1 on 2022-07-13] During this talk, I will walk you through my journey to create the Lego bricks recognition application in Python. I will start with dataset creation and introduce some Lego-specific concepts and resources. Then, I will explain a few different Machine Learning approaches to solve Lego bricks recognition task – classification, detection, and metric learning. Finally, I will show what has worked, what hasn’t, and how you can play with it yourself. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - I have to Confess, I still Love Pandas - presented by Cheuk Ting Ho [Liffey Hall 1 on 2022-07-13] In this talk, Cheuk will reapproach Pandas as someone who is a fluent user of the library. Cheuk will review why Pandas is useful to work with data and what advantage it has over the alternatives methods. As Pandas has many functionalities, Cheuk will dissect the discussion on the potential usage of Pandas in day-to-day data science workflow: data inspection, data cleaning, feature engineering etc. After discussing the advantage of using Pandas, Cheuk will discuss the flip side. What makes Pandas a difficult tool to use at first. Here Cheuk will share how she used it efficiently with new users and some fundamental concepts about Pandas. This talk is for Pandas users (new and old) or potential users. Those who are familiar with Pandas may get a refreshing idea from a new angle about the tool. And for the new users, it will be a good startup guide to make the journey of using it a bit easier. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Data Warehouses Meet Data Lakes - presented by Mauro [Liffey Hall 1 on 2022-07-13] In this talk, I will explain the current challenges of a datalake and how we can approach a moderm data architecture with the help of pyspark, hudi, delta.io or iceberg. We will see how organize data in a data lake to support real-time processing of applications and analyzes across all varieties of data sets, structured and unstructured, how provides the scale needed to support enterprise-wide digital transformation and creates one unique source of data for multiple audiences. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Elephants, ibises and a more Pythonic way to work with databases - presented by Marlene Mhangami [Liffey Hall 1 on 2022-07-13] A few weeks ago I was working on setting up a relational database to explore records from DataSF’s Civic Art Collection. Whenever I attend a tech conference I try to spend a day or two in the city to check out its cultural scene, so this seemed like useful information! I decided to use MySQL as my database engine. Coming from a Pandas background I was surprised by how unproductive and restricted I felt writing raw SQL queries. I also spent a significant amount of time resolving errors in queries that worked with one flavor of SQL but failed with MySQL. Throughout the process, I kept thinking to myself if only there was a more Pythonic way!!! A few weeks later I was introduced to Ibis. I live in Zimbabwe and the first thing that pops into my mind when I think of the word ibis is a safari. One of my favorite things to do when I'm not working is to go on a game drive. Whenever I've been adventuring on safari I usually see ibises perched on top of an elephant. The contrast between the creatures is stark! The African Sacred Ibis is a small, elegant creature that's named after the ancient Egyptian god Thoth. While as many of us know, an elephant is a very big and complex animal. This image serves as a great metaphor for the Python package and how it interacts with big database engines. Ibis allows you to write intuitive Python code and have that code be translated into SQL. Whether you’re wanting to interact with SQL databases or wanting to use distributed DBMSs, Ibis lets you do this in Python. You can think of the python code as the less complex elegant layer sitting on top of any big data engine of your choice. At the moment, Ibis supports quite a few backends including: Traditional DBMSs: PostgreSQL, MySQL, SQLite Analytical DBMSs: OmniSciDB, ClickHouse, Datafusion Distributed DBMSs: Impala, PySpark, BigQuery In memory analytics: pandas and Dask. Anything you can write in an SQL select statement you can write in Ibis. You can carry out joins, filters, and other operations on your data in a familiar, Pandas-like syntax. In this talk, we'll go through several examples of these and compare what the SQL code would look like versus writing to the database with Ibis. Overall, using Ibis simplifies your workflows, makes you more productive, and keeps your code readable. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Working with Audio in Python (feat. Pedalboard) - presented by Peter Sobot [Liffey B on 2022-07-13] Digital audio has been around for 40 years, but working with audio data can still be complicated, especially in Python. In this talk, we'll talk about how digital audio works from the ground up (from sounds, to bytes, to files), how you can use Python to do a bunch of really neat things with audio, and how a new Python library - Pedalboard - helps make working with audio much easier. Ever used a digital audio workstation (DAW) like GarageBand, Ableton Live, Logic, or Pro Tools? Today's musicians use DAWs as instruments in themselves. But what if you want to combine the power of a DAW with the flexibility of writing your own code? Pedalboard was built to fill this niche: to pull the power of a DAW into your Python code. Pedalboard makes it easy to build and apply audio effects, read and write audio files, and load audio plug-ins (""VSTs"") without any complicated dependencies or frameworks. Just `import pedalboard` and go! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Automate the Boring Stuff with Slackbot(ver.2) - presented by Takanori Suzuki [Liffey B on 2022-07-13] In addition, we often use chat such as Slack for daily communication. So, I created a chatbot(PyCon JP Bot: https://github.com/pyconjp/pyconjpbot) to automate various boring tasks related to holding PyCon JP. In this talk, I will first explain how to create a chatbot using Bolt for Python (https://slack.dev/bolt-python/concepts). I will tell you how to registers bot's integration on Slack and how to create a simple bot in Python that responds to specific keywords. And as a specific case, I will explain how to make a bot command to perform the following operations and technical problems. - Emoji reaction - Calculator: SymPy - Karma(plusplus): Peewee - Search issues, display issue details: JIRA API - Create multiple issues from a template: JIRA API, Sheets Spreadsheet API - Account management of G Suite(user, alias, group and member): G Suite API - etc. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Protocols - Static duck typing for decoupled code - presented by Ran Zvi [Liffey B on 2022-07-13] Python introduces Protocols to support static duck typing, where static type checkers (mypy) and other tools can verify code correctness prior to runtime. This was added in order to circumvent explicitly inheriting from ABCs (Abstract base classes) which is ""unpythonic and unlike what one would normally do in idiomatic dynamically typed Python code"" - according to PEP 544. We will explore the different use cases for Protocols and how to use them correctly. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Protocols in Python: Why You Need Them - presented by Rogier van der Geer [Liffey B on 2022-07-13] Protocols have been around since Python 3.8. So what are they, and how can they help you write better code? And how are they different from Abstract Base Classes? In this talk I will introduce you to both concepts (ABCs and Protocols), and show you by example how they can make your life easier, and your code cleaner. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Czech Drought Monitoring system – a journey from manual work to global drought monitoring and machine learning, powered by Python - presented by Monika Bláhová [Liffey B on 2022-07-13] This talk aims to encourage beginner developers not to underestimate the skills and benefits they can bring to various non-IT environments. I joined a team focused on drought research at the Czech Academy of Science in 2016 with a fresh degree in Geoinformatics and minimal experience with coding. Thanks to this very little initial knowledge, we were able to build a robust system providing drought monitoring and forecast for Czechia and also the whole of central Europe. We were able to fight through text files, user inputs, and geodata of all sorts and say goodbye to manual processing thanks to Python and its geospatial and data processing libraries. On the technical side, the presentation should introduce some of the handy geospatial and data processing tools to get your hands on any task, from producing colorful maps to analyzing time trends in satellite imagery. It should also be a guide on identifying needs and building the most necessary data manipulation processes from scratch. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - From pip to poetry - Python (many) ways of packaging and publishing - presented by Vinícius Gubiani Ferreira [Liffey B on 2022-07-13] Ever had issues to manage your python packages and environment? Do you know how to create and share a package to the community? It can be challenging if you've never done it, but it also doesn't have to be hard. There is always a better tool to fit our needs. In this presentation, I'd like to discuss how Python's package managers appeared and evolved with time. Discussing pip, pipenv, and poetry, presenting each of their weak and strong points. Also intend to present how to package and publish a simple code with each one of them, and suggest which package manager should you choose, whether you are just starting with python, or feel like there is something bothering and never knew you could solve it easily and painless. Slides can be accessed here: https://github.com/vinigfer/europython_2022_slides This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - The Design of Everyday APIs - presented by Lynn Root [Liffey B on 2022-07-13] What makes a good API for a library? Or more importantly, what makes it bad? Implementing an API is an art. It’s the connection between the user and the library itself. How can we optimize that connection to make the experience more pleasing? What makes a user reach for one library over another? What goes into an ergonomic API? This talk will first discuss what makes an API good: documentation, simplicity, consistency, completeness, and flexibility. We will apply those elements by looking at developing and iterating on our own library. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - When to refactor your code into generators and how - presented by Jan-Hein Bührman [Liffey A on 2022-07-13] Have you ever found yourself coding variations of a loop construct where fragments of the loop code were exactly the same between the variations? Or, in an attempt to factor out these common parts, you ended up with a loop construct containing a lot of conditional code for varying start, stop, or selection criteria? You might have felt that the end result just didn't look right. Because of the duplicated parts in your code, you noticed that the code didn't conform to the DRY (_Don't Repeat Yourself_) principle. Or, after an attempt to combine the variations into a single loop, with consequently a lot of conditional code, your inner voice told you that the resulting code had become too complex and difficult to maintain. This talk will show you a way out of this situation. It demonstrates how you can create a *generator function* that implements only the common parts of your loop construct. Subsequently you will learn how you can combine this generator function with distinct hand-crafted functions or building blocks from the standard library `itertools` module or the `more-itertools` package. As an example, imagine you'd need to implement some varying functionality based on the Fibonacci sequence. This talk shows you how it would look like before and after you've refactored it into a *pipeline of generators*. After having seen this pattern, you will recognize more quickly when this kind of refactoring helps you to create more maintainable and more Pythonic code. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - HPy: a better C API for Python - presented by Ronan Lamy [Liffey A on 2022-07-13] The official Python C API is specific to the current implementation of CPython. It has served us well and forms the basis upon which our entire extension ecosystem rests. However, it exposes a lot of internal details which makes it hard to implement it for other Python implementations (e.g. PyPy, GraalPython, Jython, IronPython, etc.), and prevents major evolutions of CPython itself, such as using a GC instead of refcounting, or removing the GIL. This is where HPy comes in. It's a new C API designed from the ground up according to the following goals: * running much faster on alternate implementations, and at native speed on CPython * making it possible to compile a single binary which runs unmodified on all supported Python implementations and versions * being simpler and more manageable than the Python/C API * providing an improved debugging experience. We'll discuss its current status and show how existing extensions can be gradually ported to it. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - PySnooper: Never use print for debugging again - presented by Ram Rachum [Liffey A on 2022-07-13] I had an idea for a debugging solution for Python that doesn't require complicated configuration like PyCharm. I released PySnooper as a cute little open-source project that does that, and to my surprise, it became a huge hit overnight, hitting the top of Hacker News, r/python and GitHub trending. In this talk I'll go into: * How PySnooper can help you debug your code. * How you can write your own debugging / code intelligence tools. * How to make your open-source project go viral. * How to use PuDB, another debugging solution, to find bugs in your code." This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Raise better errors with Exception Groups - presented by Or Chen [Liffey A on 2022-07-13] New to python 3.11, Exception Groups help you raise and handle errors more robustly than ever before - you will delve deep into the current gaps in python's exception handling mechanisms, and get to know Error Groups, and a new python keyword except*, that can be used to overcome those issues and to write cleaner code. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Taking charge of your race conditions - presented by Borjan Tchakaloff [Liffey A on 2022-07-13] Anybody working with concurrency (threads, processes, or more abstractly workers) eventually encounters a _race condition_. This kind of hair-pulling problem is a staple in computer science. Sometimes you can offload the problem to a lower layer, usually to the database engine, bundling it with atomic transactions. But there are times when you have to take charge of worst-case concurrency scenarios, when your architecture and constraints do not leave room for implicit concurrency management. Then, you need to carefully craft the paths in and out of the critical section, avoiding deadlocks along the way. In this talk, we will focus on how to test your program with a manufactured race condition. If you know it can happen, you'd better cover it in your test suite. We will define a server program called in parallel by multiple clients to illustrate the problem at hand. Then, we will manually set-up a race condition during testing to explore broken behaviour and problematic code. The Python standard library offers all the tools we need to cater for race conditions. We hope the tour we will give allows you to exercise your own race conditions more easily. Why, we even think you will have all the cards in hand to counter them! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Python & Visual Studio Code - Revolutionizing the way you do data science - presented by Jeffrey Mew [Liffey A on 2022-07-13] Visual Studio Code along with GitHub, Codespaces, and Azure Machine Learning have been investing substantially into tools and platforms to make the lives of Python data scientists easier, and we want to share why VS Code is now the #1 tool for Python Data Scientists according to the 2021 Python Software Foundation Developer Survey, and how you can leverage VS Code to take your data science productivity to the next level. This talk will walk through several common Python data science scenarios, showcasing all the productive tooling VS Code has to offer along the way. As a sneak peek, we will be demoing a best in class Jupyter Notebooks experience with VS Code Notebooks, a revolutionary new data cleaning / preparation experience with Data Wrangler in VS Code, collaboration features with GitHub and Codespaces, Azure Machine Learning for deployment, and more! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Code coverage through unit tests running in sub-processes/threads: Locally and automated on GitHub - presented by Saransh Chopra [Liffey A on 2022-07-13] The *“Code coverage”* value of a codebase depicts how much of the production/development code is covered by the running unit tests. In the world of open-source, all the maintainers try their best to keep this percentage high, and this process is often automated through tools like `GitHub Actions` and `Codecov`. Hence, code coverage becomes a good metric (not always) to check if a particular codebase is well tested and reliable. Open source maintainers often prefer to run these unit tests in sub-processes or threads as it allows them to run in parallel and reduce the `CI` (continuous integration) run time on pull requests. They also make it easier to stop the tests midway if they are taking too much time (probabilistic tests). In this talk, we will first try to use `coverage.py` in the default mode on the unit tests running in a sub-process or a thread. After going through the results, we will build a solution to cover the “un-covered” code in the local repository. As a final step, we will also configure a `CI` (continuous integration) pipeline using `GitHub Actions` and `Codecov` to automate this process in our remote repository. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Using Python to manage Software Bill of Materials - presented by Anthony Harrison [Wicklow Hall 1 on 2022-07-13] Software has become increasingly complex as it is constructed from a multitude of software components. In many cases the identification of these components are hidden as they are included through implicit dependencies. Without fully understanding the dependencies of your product it is not possible to understand the current vulnerability status of your software product or system. In the past 12 months, there has been an increasing focus on the use Software Bill of Materials (SBOMs) as a key artefact to be delivered with a software product; it will be mandated for all software products in some markets later in 2022. SBOMs which were initially developed to capture the inter-dependencies between components (the focus was on capturing the different types of open source licences used within a product) but with the latest evolution, tracking of vulnerabilities within a product can now be performed. This talk will introduce the SBOM concept and show how Python and its ecosystem can be used to create, manage and use SBOMs as part of your development pipeline. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - My journey using Docker as a development tool - presented by Haseeb Majid [Wicklow Hall 1 on 2022-07-13] Docker is a prevalent tool in our industry today, it is widely used for several proposes. In this talk, I would like to describe the journey I have taken with Docker and how I have learnt to use it with Python for local development. The talk will mostly focus on how we can use Docker to run all of our development tasks, so we hardly need to have anything installed locally. To the point where you can work on almost any project with nothing more than an editor, your terminal and Docker. We will look at how we can take a simple FastAPI web service and dockerise it. The talk will be a step by step guide, starting of with a simple Docker image and improving it iteratively. - Firstly use a simple Docker image - Then add docker-compose to dockerise its dependencies such as database - Then see how we can run tests (and other tasks) directly in our Docker container - How to use this with Github Action - Then look at multistage builds - Then split this into development and production image - How can we handle git dependencies that require an SSH key to be injected into the Docker image at build time I’d be a little more specific. Like, how we handle private pip packages in our docker images. This talk is for you if you are a casual user of Docker and know a few of its features but want to improve your Docker skills. This is NOT a talk for you if you are an expert in Docker and know most of its features. Code: https://gitlab.com/haseeb-slides/docker-as-a-dev-tool Slides: https://docker-as-a-dev-tool.haseebmajid.dev This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Event-driven microservices with Python and Apache Kafka - presented by Dave Klein [Wicklow Hall 1 on 2022-07-13] Building distributed systems can be challenging, and that's what microservices are. With traditional request/response based architectures, it is easy to end up with services that are tightly coupled, making them difficult to maintain and extend independently. While not a silver bullet, an event-based architecture makes it easier to maintain loose coupling. It also makes it easier to extend and evolve our systems without resorting to a rewrite. In this presentation, we will look at an example of an event-driven microservices application and discuss some things to consider when adopting this approach. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Managing the code quality of your project. Leave the past behind: Focus on new code. - presented by Andrea Guarino [Wicklow Hall 1 on 2022-07-13] As developers we often have to deal with legacy projects and, at the same time, we want to keep the quality and security of our deliverables under control. As soon as we start running some linter (like Pylint or Flake8) on such a legacy project, there is a huge number of violations. To handle those issues, we might want to start by only looking at the changed files in a pull request instead of the entire project, for example by using _git diff_ _pylint `git diff --name-only --diff-filter=d`_ During this talk I’d like to push this concept a bit further and outline an approach and philosophy that can be helpful in dealing with code quality : Clean as you code. 1. What is "Clean as you code"? - Not only about violations: It can be extended to code coverage and all code metrics in general. - The quality you want to measure should be based only on recent changes. 2. "Clean as you code" matters? - It helps your team stay focused on delivering new features - It helps you deal with technical debt incrementally: Sometimes you might need to modify old code, and, at that point, you might be able to fix existing violations 3. How to apply "Clean as you code"? - Shaping a *quality gate* in order to define code quality standards for the software delivered by your team today - Using appropriate tools (like SonarQube) This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - The intricate art of making your (internal) clients happy - the story from a Python-centered Infra team - presented by Paulina Winkowska [Wicklow Hall 1 on 2022-07-13] If you have ever worked on an internal company project, you may feel it deep in your bones. Let’s say that you discovered a need for a generic technological component in your organization’s tech stack. You identified stakeholders, gathered requirements, and started agile iterations on providing it. Then comes a day when you can show the MVP to your internal client! Yet… the client has lost his interest: maybe right now he says that he has already come up with his own temporary solution and he has no intention to switch to another one? Building internal products differs from commercial ones - there is no flow of cash and your clients are fully transparent. In this talk, I would like to share with you my experience and tips connected with developing such internal tools and standards. All of this from the perspective of a member of the Machine Learning Infra team that is delivering its solutions to a rapidly growing ML department in a company whose product is used by 300 million unique users per month. But let’s be specific! I will talk about: - Common pitfalls and try to dig up the reasons for why they happen when developing internal solutions - How one can approach delivering tools (spoiler: pilot programs, guilds, and more!) - Learnings from introducing such approaches (what worked, what didn’t) in our case This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Using python to predict Asset price reversals. - presented by Niall O'Connor [Wicklow Hall 1 on 2022-07-13] Using Pandas, Python and Plotly to locate potential trend reversals in Stocks, Crypto or any OHLC feed. Learn how to locate Fibonacci retrace levels and predict price reversal zones for the lowest risk entry to a trade. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - LocalStack: Turbocharging dev loops and team collaboration for cloud applications - presented by Waldemar Hummer [Wicklow Hall 1 on 2022-07-13] With the staggering dominance of public cloud providers, dev teams across the globe are increasingly focusing time and energy on optimizing their cloud development and deployment flows. The traditional deploy-and-test cycles against public clouds can become slow and tedious, where developers are often facing several minutes of idle times between deployments that need to be frequently triggered during testing & debugging. In this session, we provide a hands-on introduction to LocalStack (39k+ Github stars), a fully functional local AWS cloud stack. With LocalStack, applications can be developed entirely on your local machine, reducing dev&test cycles from minutes to seconds. The session covers interactive live coding to showcase common scenarios and use cases, different settings for local debugging of Lambdas and containerized apps (e.g., ECS/EKS), as well as some advanced new features that can radically improve productivity and team collaboration patterns. We will also glance over the large ecosystem of tools that LocalStack natively integrates with - from IaC frameworks like Terraform or Pulumi, to application frameworks like Serverless or Architect, to a whole suite of tools provided by AWS itself (CDK, SAM, Copilot, Chalice, etc). We'll wrap up the session with a deep dive into some of the Python internals of LocalStack, which reveals some interesting architectural patterns and hidden gems! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Keynote: Dodging AI Dystopia: you can't save the world alone - presented by Dr. Nakeema Stefflbauer [The Auditorium on 2022-07-13] If real life was a superhero movie, we’d have all the ingredients needed for a hero’s rescue. So many “AI” algorithms are being applied to EU education, employment, and public safety systems that you might wonder if the TV series “Black Mirror” is fiction or a blueprint for nefarious actors. Luckily, there are codes to keep dystopia at bay, whether from the fictional Justice League or from real-life courts of justice. This talk discusses both, and is aimed at software engineers, architects, designers, testers and product/project managers who want to slow the Automation of Everything, but don’t know how. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - What happens when you import a module? - presented by Reuven M. Lerner [The Auditorium on 2022-07-13] Modules are a key feature of Python, allowing us to easily reuse our own code and take advantage of publicly available modules from PyPI. It's a rare program that doesn't include at least one "import" statement. But what actually happens when we import a module? How does Python find our file? How does it decide whether it should even try to find our module? And after it finds our module file, how does Python load it into memory, assigning to its attributes? In this talk, I'll walk you through what happens when you "import" a module into Python. The mechanism is surprisingly complex, in no small part because it has to take so many possibilities into consideration. We'll talk about finders and loaders, and about the many ways in which you can customize the module-loading mechanism if you find a need to do so. If you've ever imported a module, then this talk will pull back the curtain a bit, helping you to understand what's happening under the hood. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - CPython Developer Panel - presented by Łukasz Langa, Pablo Galindo Salgado, Mark Shannon, Steve Dower, Irit Katriel, Batuhan Taskaya & Ken Jin [The Auditorium on 2022-07-13] Come meet the folks who make the Python programming language! A panel discussion of core Python developers will take place on Wednesday at 2pm. Hear what's on their mind, what they're working on and what the future holds for Python. With Pablo Galindo Salgado, Steve Dower, Batuhan Taskaya, Ken Jin, Irit Katriel and Dr.Mark ""HotPy"" Shannon. Chaired by the esteemed Łukasz ""Any color you like so long as it's black"" Langa. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - CPython bugs & risky features - presented by disconnect3d [The Auditorium on 2022-07-13] In this talk we will look into a few bug cases or doubtful features in CPython some of which are still present (and known to bugs.python.org) and may impose a security risk for admins or organizations. We will learn why running Python interpreter in random directory can be harmful which is related to interpreter libs loading, a possibility for installed modules to inject code into any Python script execution (even if the installed library is not imported), a socket.inet_aton issue that actually comes from glibc and risks involved with those cases and possible mitigations of those risks. @EDIT After talk: - Watch the talk on https://youtu.be/tRtxCCRdZOs?t=12251 - Slides are available on https://ujeb.se/pybugs This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Python Packaging Automation — Auto-Publish to PyPI via Pull Requests - presented by Justin Mayer [The Auditorium on 2022-07-13] Empowering anyone to issue a new release by submitting a pull request? At first glance, it seems like an outlandish idea. Upon further inspection, however, the benefits become clear. One of the biggest sources of friction in software development is packaging and publishing new releases. Somebody has to sift through the commits and write a change-log, tag it with a new version number, and publish the package to PyPI. And usually only one or two people have the access necessary for this last step. The unfortunate result is an infrequent release cadence. Bug fixes and new features are sitting there in the `main` branch, but hardly anybody is benefiting from them because they aren’t in a shipped release yet. Thankfully, there’s a better way: a continuous release process where new versions are auto-published via pull requests — without any manual monkeying. In this environment, all pull requests must include a release file that describes the changes within. This file must also include whether the new version should be a major, minor, or patch release. The continuous integration (CI) process looks for this file, and if one hasn’t been included, the tests will fail, and the pull request won’t be merged. Otherwise, a maintainer merges the pull request, and the CI process then uses the release file to put the description into the change-log, increment the version number, commit, tag, build, and publish the new release to PyPI. So with almost no human input, every code contribution results in a new release in a matter of minutes. Every feature and bug-fix has its own release, without anyone having to remember to package and publish a new version. Plus, if a bug is found, it’s now much easier to trace it to a specific release version. Perhaps the best part is that all contributors get to issue their own releases. What better way to welcome new contributors than to reward them with a dedicated release composed entirely of their own work? Attendees of this talk will take home the following knowledge and skills: * what kinds of problems are introduced by an infrequent release cadence * how automated releases solve those problems and provide myriad ancillary benefits * how to format and parse the release file * how to use continuous integration (CI) systems to automate releases * how to add deployment code so new versions are released when PRs are merged * how to use AutoPub(https://github.com/autopub/autopub) to facilitate this process This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Making Python better one error message at a time - presented by Pablo Galindo Salgado [The Auditorium on 2022-07-13] Python 3.10 has been recently released and among many exciting new features, one of the biggest improvements is the inclusion of a whole new set of changes focused on improving the error messages across the interpreter and the general user experience when dealing with error messages. The new error messages have been one of the most welcomed features from very different sets of users ranging from Python teachers and educators, first-time learners, industry professionals and data scientists. In this talk, we will cover: * What are the new improvements featured in Python 3.10. * Exciting new changes and improvements that will feature in Python 3.11. * How these improvements are useful to different sets of users from people learning Python to experienced programmers. * How the new PEG parser has unlocked adding new custom syntax errors. * How these improvements were implemented and what challenges the CPython core team faced to get them working reliably. * How users can contribute to adding new error messages: what is the workflow, how the errors are reviewed by the core team and where to find resources and help. No matter who you are and what you do with Python, there is an improvement that will probably make you smile. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Wednesday's Lightning Talks [The Auditorium on 2022-07-13] Signing up is on a first-come-first-served basis. The queue is reset every day in the morning. You may talk about / present (almost) everything with certain boundaries: - no promotion for products of companies, no call for 'we are hiring' (but you may name your employer). - conference announcements are limited to one minute only - one LT per person per conference policy: everyone who has not given an LT at this year's conference, yet, is ahead of you in the queue - keep it short, the shorter the presentations, the more people can give a talk See you there and have fun! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Memory Problems, Did Collector Forgot to Clean the Garbage? - presented by Pratibha Jagnere [Liffey B on 2022-07-14] In recent years, we have seen many improvements in Python Garbage Collection but there are some instances when it doesn’t work as expected. This results in memory crunch for the application leading it to crash. Although there are multiple ways to overcome the memory challenges, sometimes it is difficult to find what we can improve in our code and infrastructure that can make them memory efficient. In such cases, it helps to have an understanding of what is going on behind the curtains at a low level where memory is being managed. This presentation aims to give a quick overview of 1. How CPython manages the Memory allocation 2. Common memory errors we see in day to day production code and how we can improve them We will share what we have learned so far and encourage you to try it with your own projects. We'll walk through a simple example, with screenshots and code wherever required." This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Scalpel: The Python Static Analysis Framework - presented by Jiawei Wang [The Auditorium on 2022-07-14] Scalpel is a Python Static Analysis Framework. It provides essential program analysis functions for facilitating the implementation of client applications focusing on statically resolving dedicated problems. We aim to provide Scalpel as a generic Python static analysis framework that includes as many functions as possible (e.g., to easily build inter-function control-flow graph, to interpret the import relationship of different Python modules, etc.) towards facilitating developers to implement their dedicated problem-focused static analyzers. Scalpel’s Github page has received around 100 stars from researchers and practitioners around the world in only three-month after being made public. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Predicting urban heat islands in Calgary - presented by Anand S & Sumedh Ghatage [Liffey Hall 2 on 2022-07-14] Dealing with extreme heatwaves can be challenging, it has become the necessity to understand the land surface temperature (LST) change and its driving factors to reduce the impact and achieve more sustainable planning methods for city growth. This module will help you understand how to calculate LST from the openly available satellite imageries and merge it with urban morphological factors (like building height, building count, FSI, building block coverage, etc.) to predict the temperature trend and mitigate the impact. We will demonstrate an end-to-end methodology using geospatial Python libraries to understand the use of spatial regression methods taking into account the variation over time. This talk will also throw light upon: - Getting the large imagery datasets into DL friendly format - Spatial aggregation of different variables - Understanding correlation between variables for feature engineering - Application & comparison of different regression methods on the same data - Future scope We'll also showcase the geo-visualization portal we created and the technologies used, how you can use Python to convert large GeoJSON output to light vector tiles, and create a seamless experience for the user through an intuitive front-end. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Is the news media polarized? Or are we being conditioned to think it is? - presented by Aroma Rodrigues [Liffey Hall 2 on 2022-07-14] This work is an example of an intersection of a non scientific field with computer science and mathematics, trying to quantify, measure and identify non mathematical phenomena in the language of mathematics. It is important because it could be the basis of the scientific approaches that the next generation policy makers, voters, non profit social organizations and governments could use to make life changing decisions for their citizens. 2 The questions that this study tries to answer is whether a neural network can learn biases from the news media based on perceived bias scores obtained from independent agencies. It also seeks to answer whether any of these political leanings of the news media affect the vulnerability of their consumer when it comes to fake news. The results of this experiment aim to show Conclusions: 1. SVMs perform better clustering with respect to the categories than neural networks, however the maximum does not cross 67% 2. The most significant conclusion from this work is that though there is a perceived bias when it comes to news agencies, when looked at from a neural networks standpoint, it is negligible. Mainstream news agencies are not able to polarize a neural network with inherent biases in their headlines. 3. There may be topical biases that need to be examined by using an Entity linking and bias calculation approach 4. Most mainstream news agencies do not make the consumer vulnerable to believing fake news. This study needs to be conducted with data from popular social media ”news” groups or popular TV shows that masquerade as news but may technically not even be news channels. It is safe to conclude that the perceived bias that stems from social media polarization is being extended to news media when their contribution to the polarization may be negligible. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Common Python Mistakes with Kubernetes, How They Can Cause Vulnerabilities and How to Solve Them! - presented by Flo Pachinger [Liffey Hall 2 on 2022-07-14] In this session, we will have a look at common mistakes in Python, that can cause serious code vulnerabilities, specifically for Kubernetes deployments of the code. We will subsequently have a look at what those vulnerabilities actually can result in and how your containerized application can get ""compromised"" as a result. We will also discuss how developer and security teams struggle to talk in a common language to prevent and mitigate these vulnerabilities. Lastly, we will see how you can prevent and mitigate these vulnerabilities in real-life using tools like Falco, TUF, Open Policy Agent and Bandit. We will also see how a CI/CD pipeline should look like, to build, test and deploy something in real-life. During this session you will learn a ton, see cool demos and all of the samples will be available to the attendees afterwards. My session will benefit the ecosystem by pointing out common mistakes that can be made when writing Python code and deploying this via Kubernetes. This can cause serious breaches when exploited by attackers. The goal of the session is to both educate attendees on these vulnerabilities, as well as on how to fix them. I will be talking about multiple open source projects that can secure code and deployment. I will not cover any commercial products. Falco TUF Open Policy Agent Bandit (not CNCF) GitLab (not CNCF) This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Creating great user interfaces on Jupyter Notebooks with ipywidgets - presented by Deborah Mesquita [Liffey Hall 2 on 2022-07-14] A useful Jupyter notebook that takes input from the user to generate results is a great candidate to become a web application, but usually data scientists don't have the front-end skills required to build one and deploy them. Using notebooks with ipywidgets can be a great solution to build teams' internal tools because we get the user-friendly widgets and don't need to worry about the deployment since it's all in Jupyter. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Real-time browser-ready computer vision apps with Streamlit - presented by Yuichiro Tachibana [Liffey Hall 2 on 2022-07-14] I am the author of `streamlit-webrtc` and a member of the Streamlit Creators program (https://streamlit.io/creators) (selected community members). The repository of `streamlit-webrtc` is here: https://github.com/whitphx/streamlit-webrtc My lightning talk about `streamlit-webrtc` at PyCon JP 2021 is available: https://youtu.be/_LuLs8H1gJc Articles about this library: * Developing Web-Based Real-Time Video/Audio Processing Apps Quickly with Streamlit: https://towardsdatascience.com/developing-web-based-real-time-video-audio-processing-apps-quickly-with-streamlit-7c7bcd0bc5a8 * Real-Time Video Streams With Streamlit-WebRTC: https://betterprogramming.pub/real-time-video-streams-with-streamlit-webrtc-bd38d15f2ef3 As linked from the repo, demo apps I have developed are available online: * Demo showcase including real-time object detection: https://share.streamlit.io/whitphx/streamlit-webrtc-example/main/app.py * Source code: https://github.com/whitphx/streamlit-webrtc-example/blob/main/app.py * Real-time Speech-to-Text: https://share.streamlit.io/whitphx/streamlit-stt-app/main/app_deepspeech.py * Source code: https://github.com/whitphx/streamlit-stt-app * Real-time style transfer: https://share.streamlit.io/whitphx/style-transfer-web-app/main/app.py * Source code: https://share.streamlit.io/whitphx/style-transfer-web-app/main/app.py * Real-time Tokyo 2020 Pictogram: https://share.streamlit.io/whitphx/tokyo2020-pictogram-using-mediapipe/streamlit-app * Source code: https://github.com/whitphx/Tokyo2020-Pictogram-using-MediaPipe * Video chat: online demo is not available because it does not have an auth mechanism and is only for private use. * Source code: https://github.com/whitphx/streamlit-video-chat-example This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Use animated charts to present & share your findings with ipyvizzu - presented by Peter Vidos [Liffey Hall 2 on 2022-07-14] In this talk we'll cover the following topics: - The problem with the well-known chart taxonomies: starting from "what would you like to show" - Creating a generic chart morphing engine - Advantages of using animation for storytelling - from the presenter's and the audience's perspective - Examples and best practices of using ipyvizzu This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Scaling scikit-learn: introducing new sets of computational routines - presented by Julien Jerphanion [Liffey Hall 2 on 2022-07-14] scikit-learn is an open-source scientific library for machine learning in Python. Since its first release in 2010, the library gained a lot of traction in education, research and the wider society, and has set several standards for API designs in ML software. Nowadays scikit-learn is of one the most used scientific library in the world for data analysis. It provides reference implementations of many methods and algorithms to a userbase of millions. With the renewed interest in machine-learning based methods in the last years, other libraries providing efficient and highly optimised methods (such as for instance LightGBM and XGBoost for Gradient-Boosting-based methods) have emerged. Those libraries have encountered a similar success, and have put performance and computational efficiency as top priorities. In this talk, we will present the recent work carried over by the scikit-learn core-developers team to improve its native performance. This talk will cover elements of the PyData ecosystem and the CPython interpreter with an emphasis on their impact on performances. Computationally expensive patterns will then be covered before presenting the technical choices associated with the new routines implementations, keeping the project requirements in mind. At the end, we will take a quick look at the future work and collaborations on hardware-specialised computational routines. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Simple data validation and setting management with Pydantic - presented by Teddy Crepineau [Liffey Hall 1 on 2022-07-14] When processing data, validating its structure and its type is critical. Bad record types or changes in structure can often result in processing errors or worst in wrong data output. Yet, solving this problem cleanly and efficiently can be challenging. It often results in complicated code logic and increases complexity; consequently decreasing code readability. Pydantic is an efficient and elegant answer to these challenges We expect you'll leave this talk with a good understanding of: - Existing challenges in data validation - What Pydantic Models, Validators, and Convertors are - How to leverage Pydantic in your day to day (using real-life examples) - [Bonnus] How to use Code Generation to create Pydantic Models from any data sources This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Managing complex data science experiment configurations with Hydra - presented by Michal Karzynski [Liffey Hall 1 on 2022-07-14] Data science experiments have a lot of moving parts. Datasets, models, hyperparameters all have multiple knobs and dials. This means that keeping track of the exact parameter values can be tedious or error prone. Thankfully you're not the only ones facing this problem and solutions are becoming available. One of them is Hydra from Meta AI Research. Hydra is an open-source application framework, which helps you handle complex configurations in an easy and elegant way. Experiments written with Hydra are traceable and reproducible with minimal boilerplate code. In my talk I will go over the main features of Hydra and the OmegaConf configuration system it is based on. I will show examples of elegant code written with Hydra and talk about ways to integrate it with other open-source tools such as MLFlow. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Open Science: Building Models LIke We Build Open-Source Software - presented by Steven Kolawole [Liffey Hall 1 on 2022-07-14] Here, I elaborate on why we should develop tools that will allow us to build pre-trained models in the same way that we build open-source software. Specifically, models should be developed by a large community of stakeholders who continually update and improve them. Realizing this goal will require porting many ideas from open-source software development to building and training models, which motivates many threads of interesting research and opens up machine learning research for much larger participation. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Synergize AI and Domain Expertise - Explainability Check with Python - presented by Pranjal Biyani [Liffey Hall 1 on 2022-07-14] We will go through the Why? How? and What? of Model Explainability to build consistent, robust and trustworthy models. We explore the inability of complex models to deliver meaningful insights, cause-effect relationships and inter-connected effects within data and how explainers can empower decision makers with more than just predictions. We evaluate an intuitive game-theory based algorithm, SHAP, with a working implementation in Python. We will also pin-point intersections necessary with domain experts with 2 practical industry applications to facilitate further exploration. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - ShapePipe: A modular weak-lensing processing and analysis pipeline - presented by Samuel Farrens [Liffey Hall 1 on 2022-07-14] 1. Why would you want to listen to this talk? Cosmology is the study of the origin, evolution, structure and ultimate fate of the Universe. From the largest galaxies down to the smallest Python programmers our story begins with the *Big Bang* . The particles that make up all of things we can touch and see only account for 5% of the energy density of the Universe. Leaving us quite literally in the dark! Weak gravitational lensing, a barely perceptible change to the shape of *galaxies* that we observe, is an indispensable tool for understanding the nature of *dark matter* and *dark energy*. However, measuring the shape of galaxies to the precision required is actually quite a tricky problem. What could be more interesting? 2.What does this have to do with Python? Well, Python has steadily become the standard programming language for cosmologists over the last decade or so... and we are no exception! In this talk I will describe the tools we have developed in Python to help us solve some of the problems with measuring the shapes of galaxies and how various existing Python packages have made this possible. We hope that some of the things we have learned could be useful to other teams, in particular those developing scientific software. 3. Resources - ShapePipe Repository: https://github.com/CosmoStat/shapepipe - ShapePipe Documentation: (https://cosmostat.github.io/shapepipe/ - Slides: https://drive.google.com/file/d/1vQYCV1278oUvFzqGID6yhbQwwDyboCIv/view?usp=sharing This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - A Network Embeddings based Recommendation Model with multi-factor consideration - presented by ABHISHEK [Liffey Hall 1 on 2022-07-14] The method consists of three main steps: First, network embedding formulation performed on each user specific behavior network; Then, embeddings weight distribution estimated through intermediate layers of network with final layer for target (item purchased as labels); Finally, both factors: (a) Learned weights from implicit data (cross-domain) and (b) explicit factors from domain data used by multi-factorization method for recommendations. The proposed method transfers knowledge across implicit and explicit factors and associated dimensions. The suggested approach tested real-world data with evidence of outperforming existing algorithms with significant lift in recommendation accuracy. Empirical experimentation outcomes illustrate the potential of both factors for making effective recommendations. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - PyArrow and the future of data analytics - presented by Alessandro Molina [Liffey Hall 1 on 2022-07-14] In this talk we will introduce PyArrow and talk bout the transformation that the Arrow format is allowing in the Data Analytics world. PyArrow provides an in-memory format, a disk format, a network exchange protocol, a dataframe library and a query engine all integrated in a single library. But the Arrow ecosystem doesn't stop there and allows you to work integrating multiple different technologies. It can be a swiss army knife for data engineers and it integrates zero cost with NumPy and Pandas in many cases." This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Correlating messy data with ""correlate"" - presented by Larry Hastings [Liffey B on 2022-07-14] Data correlation! What could be more computer science-y! Ever needed to find matching items between two sets of data? Maybe even messy real-world data, with inexact string matches? Come find out how the novel scoring algorithm and clever heuristics at the heart of **correlate** solve this problem with ease!" This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Lint All the Things! - presented by Luke Lee [Liffey B on 2022-07-14] Many teams document the conventions for their projects. However, documentation gets out of date, forgotten, or sometimes ignored. Simple documentation requires team members to constantly remember all the ‘rules’ for your project. You can better enforce those rules and free up your team members to think about harder problems using linting tools like flake8, import linter, and pre-commit. These tools provide tons of useful stuff out of the box, but you can push them so much further with customization. This allows your project to formally document conventions, but also enforce them automatically on every commit, merge, and build. This can make code reviews faster and more focused on the problems your code is meant to solve. This talk will introduce tools like flake8, import linter, and pre-commit along with some of their built-in functionality. Then, we’ll briefly explore some ways to customize them to fit your projects’ specific needs. Some examples of custom linter rules we’ll tour are: - Code formatted automatically and uniformly - Code doesn’t import across architecture layers violating separation of concerns - Common conventions are used - Common anti-patterns are avoided - Specific layers are fully tested - Proper git commit message formatting - Merge commits don’t exist in topic/feature branches Finally, we’ll discuss ways to use those custom linter rules on every commit, merge, and build with continuous integration or git hooks. By the end of the talk, you’ll see several real-world linter rules used on Kraken, which is a large Django-based project used to supply green energy to millions of users across the world. In addition, expect no shortage of ideas for your own projects along the way!" This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Lessons learnt from building my own library - presented by Stephanos [Liffey B on 2022-07-14] This talk is about all the mistakes that I made while building a library, how I would have avoided making them if I started today, what turns I would have taken differently, what choices I made, and why I made them. Examples are drawn from the building of a specific library, but it's not about a specific one. The aim is to give some insights more into how to make choices when building a library available to the world, and less on the specific set of choices that I made. It will not be technically challenging, but some familiarity with the Python ecosystem is advised." This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Revolutionizing Education: How Python is Essential Beyond Computer Science - presented by Srivatsa Kundurthy [Liffey B on 2022-07-14] Introduction and Motivation: The goal of many within the Python community has been to increase the reach of computer science education in classrooms and institutions around the world. Various studies have pointed out the problem-solving and planning abilities forged by computer science coursework (Salehi et al., 2020; Arfé et al., 2020), and other research has investigated the social stigma (McCartney et al., 2017) and instructor bottlenecks (Raman et al., 2015) that inhibit accessibility to computer science courses. In recent years, significant steps have been taken towards increasing computer science education. However, most of these efforts are largely focused on the introduction of standalone computer science courses rather than integrated coursework. In this talk, we explore the seldom-discussed idea of integrating programming into traditional, non-computing fields such as mathematics, social studies, and science. Interdisciplinary coursework is not a new concept in education: students in an English class are expected to be able to understand, produce, and analyze data visualizations, and mathematics students learn to communicate their work formally in language (Lynch, 2020). However, the current belief in the education realm is that computer science is only for a small sect of highly capable students expressing a deep career interest in the field, a clear misconception that has been debunked by studies (Patitsas et al., 2019) and the experiences of countless professionals applying computational resources in traditionally non-computing industries. As a result of such factors, computer science education is fundamentally isolated from the core curriculum, which is to the detriment of learners and the fields that they pursue. In support of the discussion, we unveil the results of surveys given to physics students enrolled in college-level coursework. In this case-study, students of varied backgrounds in computing are given a lecture on chaotic dynamical systems, and are then shown Python-implemented Runge-Kutta numerical integration methods and simulations to solve and visualize the systems. The insights provided by these students provide great perspective on benefits, reception, and nuances in integrating Python into core classes. Overwhelmingly, many indicated that they believed that the Python demonstrations aided in their understanding of the material. For the attendee, this exclusive look at a case-study will help develop a well-informed perspective on the role of Python beyond just computer science. We conclude the presentation with recommendations for integrated Python coursework, calling for global policymakers and Python community members to step forward and do their part as stakeholders. We pinpoint why Python is the best choice, touching on factors such as its readable syntax, high volume of functional open-source libraries, ever-growing industry demand. The versatility afforded by such elements makes learners of all backgrounds better equipped for solving the challenging problems they will face in their careers. Community members in attendance will gain essential knowledge regarding the issue of Python integration, making them better equipped to argue on behalf of the educational community. For students, seeing how complex differential equations can be numerically approached and solved by computers, understanding how new solar systems are discovered by crunching vast astronomical data, and witnessing a computer rapidly sequence a lengthy DNA chain forges an instant, permanent connection that fosters career interests and prepares students for an increasingly computerized professional world. We seek to advocate for every student to have this opportunity. The key takeaway for talk attendees will be a fresh perspective on the issue of Python’s absence beyond the confines of computer science coursework, as well as methods for mitigation and steps that they can take. Changing education with programming is a long-term investment that will unequivocally accelerate student preparedness and capabilities, but it begins with the focused efforts of an informed public rallying in support of progress. Schedule and Format: 5 minutes: The problem of computer science in education and why we should focus on increasing Python’s role in non-computing classes 10 minutes: Presenting research: a case study on introducing scientific Python to physics students 5 minutes: Why Python is the best option and the role and impact on the Python community 5 minutes: Proposals for Solutions to the Problem 5 minutes: Question and Answer Session" This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Creating the Next Generation of Billionaires - Part 4 - presented by Lilian [Liffey B on 2022-07-14] Our generation of young people in school (aged 5-18) have noticed the connection between Computer pRogramming, Technology, Bitcoinism Success, Climate Change and Billionaires. On mass young people are clamouring to master the skill of Computer pRogramming. It has been dubbed the ‘4th’ R’ (computer pRogramming) along with Reading, wRiting and aRithmetic. So, governments worldwide have launched initiatives to have it taught in schools from Kindergarten to all the way to high school. And now young people are successfully mastering this skill. This talk will describe a case study whereby Computer Programming (Python) was introduced for the first time to a group of young people and how the young people are using it to explore and understand real world problems and data such as those relating to climate change, world population growth and carbon dioxide emissions with Python visualisation libraries such as Matplotlib, Numpy and Pandas. We will talk about the joys and challenges and discoveries made by the young people. We will conclude with suggestions on how to proceed in this area." This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Developers Documentation: your secret weapon - presented by Frédéric Harper [Liffey B on 2022-07-14] You can have the best product in your expertise area, but if your documentation isn’t on par with the flawless experience you want to offer to the world, success is not guaranteed. Let’s be real here: documentation is often an afterthought and rarely included in life cycle development processes. Still, documentation is the secret weapon for greater adoption, and growth that you may have not known you could achieve. It’s time for you to step up your game and measure up to the big players. Learn about the benefits of high quality and educational documentation and the true role it plays in the developer community. You’ll also learn the principles of a solid foundation, and tips on how to use one of the most powerful developer relations’ tools. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Build-A-Database with Python - presented by Sangarshanan [Liffey A on 2022-07-14] This talk will help unlock the internal workings of a Database by breaking down the abstractions that make it. We will use Python as our weapon of choice to slowly discuss how you would go about building the different components of a database. 1) Talking to your Database: We start by building out an interface and a language that helps us communicate with our database. We will use the Prompt toolkit to build a REPL & use a simple SQL-based language with basic regular expressions that can parse it to instruction to execute. 2) Working with Data: Now that we can communicate with our database using instructions. we start the actual work in building out the Datastore, We initially store all the data in a simple in-memory dictionary and then move to persist this data to disk. We now read the data from the disk to memory every time we query the data and write back the data to the disk but this makes things very slow :( This problem is our entry into the beautiful world of Indexes so by building a very basic Btree index to store references in memory to quickly access only what we require from the data on disk we can actually speed up our access times for basic row access queries from O(N) to O(1) where N is the number of rows in a table 3) Future: We can now proudly demo our new and polished database that can store data, persist it, and can run queries that are quite fast thanks to our Btree Indexes. We also discuss how this Database can be improved in the future by supporting full ACID Transactions, allowing concurrency, and handling locks Our Database journey now comes to an End and As they say, The best way to understand something is to build it yourself :) This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Debugging asynchronous programs in Python - presented by Andrii Soldatenko [Liffey A on 2022-07-14] Luckily, when it comes to debugging asynchronous applications in python, we have a couple of options to consider. The writers of the asyncio module have very kindly provided a debug mode, which is quite powerful and can really aid us in our debugging adventures without the overhead of modifying the system's code base too dramatically. In particular, I'll show you what asyncio debug mode means for developers, and how to source tracebacks for unhandled exceptions in futures. Also how to detect accidental blocking for I/O. We discuss how to monitor the asyncio event loop and collect metrics in statsD. Finally, we discuss monitor and cli capabilities for asyncio applications based on aiomonitor and aioconsole. Also, we discuss how asynchronous python works in REPL via autoawait based on ipython and how to do it in vanilla python REPL. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Self-explaining APIs - presented by Roberto Polli [Liffey A on 2022-07-14] This talk will present strategies and python tools to create semantically interoperable REST APIs. After the problem statement, various solutions will be presented, including: * contract-first api development with OpenAPI 3, ontologies and controlled vocabularies like the ones published by the European Union (https://op.europa.eu/en/web/eu-vocabularies/authority-tables); * the rdflib and pyld python libraries for processing json-ld and RDF files (https://en.wikipedia.org/wiki/Resource_Description_Framework); * the use of centralized catalogs such as schema.org. Prerequisites: * no prior knowledge of semantics and ontologies; * practical experience with OpenAPI, json schema and data modeling and API design in general. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - EuroPython 2022 Sponsor Highlight & Recruitment [Liffey A on 2022-07-14] Many of our sponsors are looking to hire talented people and EuroPython is the perfect place to reach out to them! In this session, our sponsors will each give a short presentation about their company and what they do with Python. You can then approach them directly at their booth to discuss more details. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - A Tale of two Kitchens, hyper modernizing your codebase. - presented by Christian Ledermann [Liffey A on 2022-07-14] A Consistent style and standard and the consistent use of the same tools in all your code, makes it easier to reason about, reduces context switching, thus reducing waste (in the LEAN sense). A clean environment is good for your health and safety, enabling you to deliver quality faster. This talk goes deeper into how to modernize your legacy codebase to reduce your technical debt, to make it easier for you to tackle the real challenges without ever having to discuss a style guide again. It will provide tips, tricks and tools to make your “hypermodernization” effort as smooth and easy as possible. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Forget Mono vs. Multi-Repo - Building Centralized Git Workflows with Python - presented by Daniel Koch [Liffey A on 2022-07-14] The mono vs. multi-repo is an age-old debate in the DevOpsphere, and one that can still cause flame wars. What if I were to tell you that you don't have to choose? In this talk we will dive into how we built a centralized Git workflow that can work with any kind of repo architecture, delivered with Python. One of the greatest recurring pains in CI/CD is the need to reinvent the wheel and define your CI workflow for each and every repository or (micro)service, when eventually 99% of the config is the same. What if we could hard reset this paradigm and create a single, unified workflow that is shared by all of our repos and microservices? In this talk, we will showcase how a simple solution implemented in Python, demoed on Github as the SCM, and Github Actions for our CI, enabled us to unify this process for all of our services, and improve our CI/CD velocity by orders of magnitude. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Let's talk about JWT - presented by Jessica Temporal [Wicklow Hall 1 on 2022-07-14] JSON Web tokens dominated the way we give access to APIs and how we carry data from users, but to use JWTs safely we need to understand how they came to life and how JWTs can be useful. In this talk we will take a closer look at the famous three-part structure that forms a JSON Web Token, and the claims each JWT can carry. But knowing it’s history and structure is not enough, we need also to understand the algorithms used in creating a token and how you can use JWTs as access tokens or as ID tokens. After understanding JWTs on a deeper level, we will create and validate a JWT together using the PyJWT library and discuss things you should avoid doing to be safer when using JWTs in your projects. 1. How did JWT come to life? Talk about the JOSE specification; 2. What actually is a JSON Web Token and its structure: header, payload, and signature; 3. What is a claim and its standardization efforts; 4. The different types of algorithms that can be used to create JWTs and what is JWKs; 5. Let's create a token together using PyJWT; 6. What is an access token and an ID token; 7. Things to avoid to be safer with JWTs This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Robyn: An async Python web framework with a Rust runtime - presented by Sanskar Jethi [Wicklow Hall 1 on 2022-07-14] With the effort put in at every Python version to increase the runtime performance, we know that throughput efficiency is one of the top priority items in the Python ecosystem. Inspired by the extensibility and ease of use of the Python Web ecosystem and the increased focus on performance, Robyn was born. Robyn is one of the fastest, if not the fastest Python web framework in the current Python web ecosystem. With a runtime written in Rust, Robyn tries to achieve near-native rust performance while still having the ease of writing Python code. This talk will demonstrate the reasons why Robyn was created, the technical decisions behind Robyn, the increased performance by using the rust runtime, how to use Robyn to develop web apps, and most importantly, how the community is helping Robyn grow! Finally, I will be sharing the future plans of Robyn and would love to get feedback from the developers to see what they would like to see in it. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - How I wrote a Python client for HTTP/3 proxies - presented by Miloslav Pojman [Wicklow Hall 1 on 2022-07-14] MASQUE (https://tools.ietf.org/id/draft-schinazi-masque-01.html) (Multiplexed Application Substrate over QUIC Encryption) is a draft of a new protocol that allows running proxy or VPN services indistinguishable from HTTPS servers. Akamai built a managed proxy service based on the MASQUE protocol to provide egress proxy (https://www.akamai.com/blog/cloud/powering-and-protecting-online-privacy-icloud-private-relay) for iCloud Private Relay. While working on the proxy at Akamai, I wrote a Python client for testing the proxy service. The MASQUE protocol can tunnel traffic through HTTP/3 or HTTP/2, but common Python libraries only support HTTP/1.1. The tunneled traffic can use any protocol on top of TCP or UDP, including all HTTP versions, so MASQUE can be proxied through MASQUE for onion routing. In this talk, I will show that the MASQUE proxy design is simple and yet client implementations are complex. To put everything into context, I will recap how HTTP proxies operate and how HTTP versions differ. I will highlight lessons learned from designing a low-level HTTP client using Python asyncio. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - When gRPC met Python - presented by Sanket Singh [Wicklow Hall 1 on 2022-07-14] gRPC is one of the most new breakthroughs in the world of client server interaction. Using gRPC our client can directly make a call to a server on a different machine as if it were a local object. gRPC has low latency, high scalability and supports multiple use cases for distributed system. We can even build mobile clients which can communicate to a cloud server. gRPC uses Protocol Buffers which is an open source mechanism for serializing structured data, which makes payloads faster, smaller and simpler. In this talk we will try to understand how can we get started with gRPC in Python. grpcio package of python will be used for the demonstration of the examples and we will cover basics of gRPC as well. We will build a basic gRPC service and define protocol buffers for it. Demonstration of how a client and a server can be made through gRPC and how can they communicate. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Async Django - presented by Ivaylo Donchev [Wicklow Hall 1 on 2022-07-14] This talk will cover: 1. What is the difference between asynchrony and concurrency? 2. Python and Django tools for asynchronous programming. 3. Examples of efficient and inefficient "async" Django views. 4. How does Django handle requests asynchronously - the path from `NGINX` to the database 5. How should we handle thread-blocking operations? 6. A brief history and roadmap of Django's async support This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Maps with Django - presented by Paolo Melchiorre [Wicklow Hall 1 on 2022-07-14] A _map_ in a website is the best way to make geographic data easily accessible to users because it represents, in a simple way, the information relating to a specific geographical area and is in fact used by many online services. Implementing a web _map_ can be complex and many adopt the strategy of using external services, but in most cases this strategy turns out to be a major data and cost management problem. In this talk we'll see how to create a web _map_ with the *Python* based web framework *Django* using its *GeoDjango* module, storing geographic data in your local database on which to run geospatial queries. Through this intervention you can learn how to add a _map_ on your website, starting from a simple _map_ based on Spatialite/SQLite up to a more complex and interactive _map_ based on PostGIS/PostgreSQL. Slides: https://www.paulox.net/2022/07/14/europython-2022/ This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Walk-through of Django internals - presented by Hitul Mistry [Wicklow Hall 1 on 2022-07-14] ⭐ Talk will start with the introduction of how does end to end web request works internally in Django. ⭐ The talk will introduce users to the internals of ORM, database backend, middleware, etc. ⭐ The talk will also cover, all processes Django does internally to start a server. ⭐ At the end of the talk attendees will be able to understand the internal code structure of Django, how does Django server start, how does Django serves the requests, etc. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Thursday's Lightning Talks - presented by [The Auditorium on 2022-07-14] Signing up is on a first-come-first-served basis. The queue is reset every day in the morning. You may talk about / present (almost) everything with certain boundaries: - no promotion for products of companies, no call for 'we are hiring' (but you may name your employer). - conference announcements are limited to one minute only - one LT per person per conference policy: everyone who has not given an LT at this year's conference, yet, is ahead of you in the queue - keep it short, the shorter the presentations, the more people can give a talk See you there and have fun! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Automate cleaning code in few easy steps! - presented by Ester [The Auditorium on 2022-07-14] Have you ever been in a situation where you check your pipelines to see if he’s finished running the tests and you find that he hasn’t even started because you forgot to run the linters locally? I contribute to the development of PyCon Italia (https://pycon.it), Strawberry GraphQL (https://strawberry.rocks) and Poetry Package Manager and coding with these organizations I discovered fantastic tools such as pre-commit (https://pre-commit.com/), Poetry (https://python-poetry.org) and many others. In this talk I would like to share with you my findings, think about the pros and cons and understand a little bit better why you should start using them. Slides available here: https://www.slideshare.net/EsterBeltrami1/automate-cleaning-code-in-few-easy-steps This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Diversity & Inclusion in the Python Community Panel - presented by Tereza Iofciu, Marlene Mhangami, Naomi Ceder, Nabanita Roy & Iqbal Abdullah [The Auditorium on 2022-07-14] Come meet some of the folks working on Diversity and Inclusion in the global Python Community! Join the live panel discussion to hear about the challenges and the work they do. With Marlene Mhangami, Nabanita Roy, Iqbal Abdullah, Tereza Iofciu. Chaired by Naomi Ceder. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Online voting system used for primary elections for the French Presidential, must be secure right? - presented by Emmanuel Leblond [The Auditorium on 2022-07-14] Since its inception, online voting has been an appealing but controversial technology. Indeed, what seems like a modern way of making vote cheaper and more convenient is often considered by activists and researchers as a pandora's box unleashing never-ending privacy and authenticity concerns. However with Covid 19 shrinking our public interaction, many have considered the benefits to overcome the theoretical issues and the online voting systems have skyrocketed like never before... The Neovote voting system has been massively used in France: tenths of University, hundreds of private companies, and, more importantly, it was chosen to organize 3 of the 5 main primary elections for the French Presidential election of 2022 (Primaires de l'Écologie, Les Républicains and Primaire Populaire). Neovote claims to have the highest possible level of security, the voter being even able to access the final ballot box to do the recount by himself and ensure his own vote has been taken into account! So challenge accepted, this talk will walk you through the Neovote voting system to understand why their claims are "slightly" exaggerated ;-) This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - How we are making Python 3.11 faster - presented by Mark Shannon [The Auditorium on 2022-07-14] The "Faster CPython" project aims to speed up Python, specifically CPython, by a large factor over the next few releases. The first release to see the benefits of this work is Python 3.11. Python 3.11 includes the following major changes: * Adaptive specializing interpreter (PEP 659) * Consecutively allocated execution frames * Zero cost try-except * More regular object layout * Lazily created object dictionaries. I will describe each of these, describing how each helps speed up Python, and how they interact with each other. I will end the talk with some possible directions for Python 3.12. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Writing Faster Python 3 - presented by Sebastian Witowski [The Auditorium on 2022-07-14] Did you know that Python preallocates integers from -5 to 257? Reusing them 1000 times, instead of allocating memory for a bigger integer, can save you a couple milliseconds of code’s execution time. If you want to learn more about this kind of optimizations then, … well, probably this presentation is not for you :) Instead of going into such small details, I will talk about more “sane” ideas for writing faster code. After a brief overview of different levels of optimization and how they work in Python, I will show you simple and fast ways of measuring the execution time of your code and finally, discuss examples of how some code structures could be improved. You will see: * The fastest way of removing duplicates from a list * How much faster your code is when you reuse the built-in functions instead of trying to reinvent the wheel * What is faster than the “for loop” * If the lookup is faster in a list or a set * When it’s better to beg for forgiveness than to ask for permission This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Keynote: Killer Robots Considered Harmful - presented by Laura Nolan [The Auditorium on 2022-07-14] Killer robots may sound like something from a movie, but in recent years weapons have been developed that can select targets and attack without any human input, and expert systems have been used to assist in military targeting. Some argue that this is a positive development, because automation can increase precision in targeting and reduce civilian casualties. However, others point out that highly automated systems do not have a good track record in complex and high-stakes real-world situations, and military conflict is unlikely to be better. This talk will outline the technological underpinnings of autonomous weapons and automated targeting systems, as well as examining the legal and ethical debate over these systems that has been happening at the UN over the past decade. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - When Models Query Models - presented by Michal Maciejewski [Liffey Hall 1 on 2022-07-15] The design of large-scale engineering systems, including but not limited to aerospace, particle accelerators, nuclear power plants, is carried out by a wide range of numerical models such as CAD files, finite-element models, and machine learning surrogate models to name a few. In order to provide a uniform modelling interface, we encapsulate numerical models in notebooks. A notebook is controlling model creation, execution, and query of results. Numerical solvers are embedded into Docker containers and provide an isolated and reproducible environment exposing a language-agnostic REST API. A model registry enables efficient queries of models. The overall system is represented as a collection of models that exchange data. Then, the design optimization involves execution of a dependency tree of models to study the impact of a parameter change and perform its optimization. In this contribution, we present a model query mechanism allowing notebook models to query one another. The model dependencies are represented with a graph with suitable processing algorithms. In order to ensure that only affected models are executed we derive and cache a model resolution order. The presented modelling framework relies on open source-technologies (packages: pydantic, Fast API, Jupyter, papermill, scrapbook, containers: Docker and Openshift as well as databases: MongoDB and Redis) and the talk will focus on good practices and design decisions encountered in the process." Licence: https://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Writing secure code in Python - presented by Yan Orestes [Liffey B on 2022-07-15] Is your Python code secure? This talk will show how some inattentions, mistakes and assumptions that we, as developers, carry in our code can lead to serious vulnerabilities in our applications. All of that, of course, with lots of examples! At the end, the talk will present a simple way to audit Python code in order to facilitate the maintenance of your security with the identification of possible vulnerabilities. - Learn how `eval()`, pickle, and pip are vulnerable to arbitrary code execution - Understand the importance of cryptographically-secure randomness - Learn how to audit your code and keep your programs secure - ... and more!" Licence: https://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - From circuit board design to finished product: the hobbyist’s guide to hardware manufacturing - presented by Sebastian Roll [Liffey Hall 2 on 2022-07-15] Ever wondered how hardware is made, or curious about making your own? We share our experiences manufacturing a programmable gamepad for use in IoT/MicroPython workshops. We will cover the entire production process, including: - Designing the PCB (Printed Circuit Board) - Choosing microcontroller and parts - Finding, ordering and assembling components - Pulling together firmware, drivers and software Mistakes were indeed made along the way. Let's turn them into valuable lessons! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Try Something Different: Explore MicroPython! (a rough guide for newcomers) - presented by Andy Piper [Liffey Hall 2 on 2022-07-15] MicroPython is a reimplementation of Python for microcontrollers, originally developed as a result of a Kickstarter campaign. Today, it is an approachable way into programming for many young people, via boards like the Raspberry Pi Pico, the BBC micro:bit and the CodeBug - you can even run it on LEGO bricks! It is increasingly being used in commercial fields as well. MicroPython is helping Python to get into even more places, and making programmers more efficient as it does so. Andy Piper wanted to learn more, so he spent some time travelling and adventuring on the internet, to discover the community and projects around MicroPython. The goal of this session is to briefly explain the What, Why and How of MicroPython. There *will* be circuit boards, and discussion of microcontrollers! We will take a look at examples, from established development boards to brand new ones. We will also acknowledge how MicroPython has been built upon, to enable different ways of working (with CircuitPython), and LEGO robots (via PyBricks). Finally, and most importantly, you'll get a good sense of the places you can find and learn from the MicroPython community, and how you can get involved and contribute! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Saving Lives with Predictive Geo - AI - presented by Sumedh Ghatage [Liffey Hall 2 on 2022-07-15] We will demonstrate an end-to-end methodology using geospatial Python libraries to understand the use of Multi-Criteria Decision making methods taking into account driving variables. This talk will also throw light upon: 1. Getting the large imagery datasets into DL friendly format 2. Resampling of Satellite image data in python 3. Conducting overlay analysis with weights 4. Calculation of zonal statistics at house level 5. Future Scope We'll also showcase the geo-visualization portal we created and the technologies used, how you can use Python to convert large GeoJSON output to light vector tiles, and create a seamless experience for the user through an intuitive front-end. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Unfolding the paper windmills - presented by Mai Giménez [Liffey Hall 2 on 2022-07-15] Research is done on the shoulders of giants. Luckily and unluckily, those giants spoke paper-English and documented their achievements kind of publicly so we could advance the science. In this talk, we will dissect the structure of a paper, looking for the essential points that will help us understand it and implement it. Following we will get our hands dirty and implement the paper using Python. In particular, we will dive into the seminal paper ""Attention is all you need"" and implement a transformer using JAX. The key takeaways from this talk are: - Demystify academic reading. - Understand the Transformer architecture. - An introduction to the JAX ecosystem. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Mercury - Build & Share Data Apps from Jupyter Notebook - presented by Piotr Płoński [Liffey Hall 2 on 2022-07-15] The Mercury (https://github.com/mljar/mercury) is a new framework for converting Jupyter Notebook to a web app. The widgets are constructed based on the YAML config (similar to R Markdown). The user can tweak the values of the widgets and execute the notebook from the top to the bottom. The notebook sharing is as simple as sending a link. What is more, you can decide whether to show or hide the code. In the talk, I would like to show how the Python notebook can be converted to a web app and deployed to the cloud. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Jupyter - Under the Hood - presented by Dhanshree Arora [Liffey Hall 2 on 2022-07-15] Jupyter Notebooks at their core are just JSON documents that contain all your code, markdown styles and outputs. Yet when you run a notebook, there's a lot that's happening under the hood - from starting a session with the notebook server, to launching an IPython kernel, and a rich Web UI communicating with the notebook server and the IPython kernel using Jupyter's REST APIs and ZMQ websockets. We will explore the Jupyter ecosystem and see how this system comes together. The architecture of all the offerings in the Jupyter Project (such as the classic Jupyter Notebook), the newer JupyterLab IDE, or the scalable multi-user environment - JupyterHub is completely distributed. At their core, there's a front end client like a web browser or a qt console that talks to the Notebook server using its many APIs (like the kernel API) and to the language kernel (in our case IPython) using ZMQ Sockets, allowing the Jupyter architecture to scale easily. In this presentation, we look closely at these REST API calls, and the ZMQ socket traffic using simple tools like the browser's network tab. We will also try to manipulate a notebook using simple code to get a full appreciation of these internals. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Build your own Playlist Recommender System with Python using your GDPR Data - presented by Marcel Kurovski [Liffey Hall 1 on 2022-07-15] Personalized Playlist Recommendations on Spotify are great – some of them let us discover new songs, some others help us to rediscover songs. However, rediscovery seems to be limited on the more recent past, i.e. going only a month backwards. This is a problem if you like to rediscover some of your favorite songs you might have listened to a longer while ago. Sometimes we add them to our ""liked songs"" where they likely fade away. However, you once explicitly declared those tracks as favorites. So, what is it that we can do about this missing piece in personalized playlist recommendations? Well, the first thing we do is to request our personal usage data from Spotify according to GDPR. Second, we analyze and enrich it with track audio features offered by Spotify’s rich Web API. We derive the music taste profile of ourselves from 12 months of streaming history and use this taste profile to retrieve favorite songs we haven’t listened to for more than a year. In my talk, I present you the Python package I build for this purpose, possible extensions and enable you to create your own personalized playlist to rediscover your past! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Native Packaging of GUI Apps on Windows and macOS - presented by Tiago Montes [Liffey Hall 1 on 2022-07-15] Distributing Python GUI applications to end users is a challenge: will they need to install Python? If so, which version? If not, how do they install the application? From a random ZIP file? How native does the process feel? Will their system trust your code? For a fluid experience, it needs to be signed and (on macOS) notarized beforehand. Welcome to `pup` (https://pypi.org/project/pup/), the tool that the Mu Editor (https://codewith.mu/) development team has created to package and distribute it in platform-native formats to Windows and macOS users around the world. In this session I will show how `pup` can be used to package GUI Applications for distribution: natively on Windows and macOS, and in early stages of development for distribution-agnostic Linux artifacts. In short, if it's `pip`-installable it is `pup`-packageable! I will then describe the way `pup` works (and how it differs from comparable tools) leading on to a call-for-action moment, where I'll share its current state of development, what's good, what's bad, and where I'd like it to be headed to. I'll wrap up the talk with a set of future-looking thoughts that `pup` has helped identify not only on the specifics of CPython's distribution, but also on the Python ecosystem as whole. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Packaging Python in 2022 - presented by Jeremiah Paige [Liffey Hall 1 on 2022-07-15] The Python packaging landscape is experiencing a renaissance but along with new standards and new tools comes a lot of new choices when publishing. setup.cfg or pyproject.toml? Do you need a setup.py instead or in addition? There can be a lot of confusion but understanding modern trends can make sharing your code easier than ever before. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Machine Translation engines evaluation framework - presented by Anton Masalovich & Sahil Manchanda [Liffey Hall 1 on 2022-07-15] Task of Machine Translation engine evaluation may be very challenging. Quality of Machine Translation varies greatly depending on domain and language pair. Different MT engines may have different interfaces or APIs and different requirements to run. To add to that, even definition of a good translation may be debatable, with any automatic MT quality metric providing only approximation of actual translation quality. That's why having universal evaluation framework for this task is very important. In our work we tried to create such framework. 1) We defined base translation class that unified all file handling, batch creation and result processing. As a result of that, only work needed to support new MT engine was creation of small child class that implemented couple of simple functions. That allows us to easily extend our framework to MT engines and new language pairs. 2) We defined set of test datasets and provided a way to add new datasets to this set. For our evaluation our aim was to create test data that covers both general and healthcare domains EMEA dataset (https://opus.nlpl.eu/EMEA.php), OPUS-100 (https://opus.nlpl.eu/opus-100.php), Paracrawl (https://paracrawl.eu/) and several others. But our data preparations scripts can be easily extended to other domains and datasets as well. 3) We defined a set of quality metrics to evaluate results of MT engines. Metrics that we used included BLEU (https://github.com/mjpost/sacrebleu), BERTScore (https://github.com/Tiiiger/bert_score), ROUGE (https://github.com/pltrdy/rouge), TER and CHRF (both also from sacrebleu implementation). Beside MT evaluation framework we will present our own evaluation results. For our evaluation we used cloud based engines - Azure Translator (https://azure.microsoft.com/en-us/services/cognitive-services/translator/), Google Translate (https://cloud.google.com/translate/), as well as open-source engines - Marian MT (https://huggingface.co/transformers/model_doc/marian.html), NVIDIA's NeMo (https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/stable/nlp/machine_translation.html), Facebook's MBart 50 (https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt), Facebook's M2M100 (https://huggingface.co/facebook/m2m100_418M). For open source engines we tried to use Huggingface's transformer implementation whenever possible. But as we mentioned our framework was designed in a way to be easily extendable to other MT engines and underlying frameworks. We also will present evaluation results for NeMo and MarianMT engines that we fine-tuned specifically for healthcare domain. While these particular results may rather specific to our use case, they help to highlight how our framework can be extended to custom MT engines as well. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - AI for Content Moderation at PayPal - presented by Raghotham Sripadraj & Ryan Roggenkemper [Liffey Hall 1 on 2022-07-15] Online content moderation at scale is a non trivial task especially with an ever changing landscape of hate, hate speech with changing geopolitical scenarios. Moderation platforms need to support multiple typologies like - hate, sexually explicit, violence, bullying, spam and other toxic material. Add multi-language support for all typologies and it becomes an uphill task. In this talk we will cover the below topics: 1. Why is Text Content Moderation is hard? Why we need AI? 2. What are the available open-source datasets to train models? 3. What are the available pre-trained models for content moderation? 4. Why pre-trained models do not always work? 5. Data labelling strategies and how to leverage open data and models? 6. How to build multi-language support and challenges? This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Handling Errors the Graceful Way in Python - presented by Riya Bansal [Liffey B on 2022-07-15] In the process of programming, we are always going to encounter various errors. Things rarely go as planned, especially in the world of programming. Errors are unavoidable when writing code, which can be frustrating at times. Every single one of us has faced this issue and emerged from it a better programmer. Dealing with bugs and errors is what builds our confidence in the long run and teaches us valuable lessons along the way. So, in this talk, we'll discuss different ways of handling errors and making our lives a little better. We'll talk about how code written with effective exception handling strategies can help us to catch bugs early in the software developmental cycle. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Secure Python ML: The Major Security Flaws in the ML Lifecycle (and how to avoid them) - presented by Alejandro Saucedo [Liffey B on 2022-07-15] - Abstract Every phase across the end-to-end machine learning lifecycle exposes a plethora of security risks that often go unnoticed by machine learning practitioners. In this talk we uncover the most critical (and common) security risks in the machine learning lifecycle, covering in-depth concepts as well as practical examples of ways in which these can be exploited as well as resolved and mitigated (analogous to the OWASP Top 10 industry standard). Throughout the talk we will be using a hands on example, where we will be training, packaging and deploying a model from scratch, outlining key risk areas for each step together with tools and practices that can be used to mitigate these risks. By the end of this talk, machine learning practitioners will have a robust intuition of the importance of security best practices throughout the machine learning lifecycle, together with tools and frameworks that can help mitigate undesirable outcomes due to security flaws. - Overview The operation and maintenance of large scale production machine learning systems has uncovered new challenges which have required fundamentally different approaches to that of traditional software. The area of security in MLOps has seen a rise in attention as machine learning infrastructure expands to further critical usecases across industry. In this talk we introduce the conceptual and practical topics around MLSecOps that data science practitioners will be able to adopt or advocate for. We will also provide an intuition on key security challenges that arise in production machine learning systems as well as best practices and frameworks that can be adopted to help mitigate security risks in ML models, ML pipelines and ML services. We will cover a practical example showing how we can secure a machine learning model, and showcasing the security risks and best practices that can be adopted during the feature engineering, model training, model deployment and model monitoring stages of the machine learning lifecycle. - Benefits to the ecosystem This talk will provide practitioners with the intuition and tools to secure production machine learning systems, as well as further the discussion around best practices reinforcing SecOps into MLOps. It will provide best practices on a critical area of machine learning operations which is of paramount importance in production. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Rapid prototyping in BBC News with Python and AWS - presented by Ben Nuttall [Liffey B on 2022-07-15] BBC News Labs is an innovation team within BBC R&D, working with journalists and production teams to build prototypes to demonstrate and trial new ideas for ways to help journalists or bring new experiences to audiences. We work in short project cycles to research and build prototypes. We have worked with the BBC's flagship radio news programme production team to enrich programme timelines with metadata to provide enhanced experiences to the audience. We are currently working with local radio teams around the UK to provide the means to capture highlights in live radio for re-use and for social media, reducing the workload for producers, and getting more mileage from linear broadcast programmes. Working in short cycles, it's important for us to be able to quickly build processing pipelines connected to BBC services, test and iterate on ideas and demonstrate working prototypes. We make use of modern cloud technologies to accelerate delivery and reduce friction. In this talk I will share our ways of working, our ideation and research methods, and the tools we use to be able to build, deploy and iterate quickly, the BBC's cloud deployment platform, and our use of serverless AWS services such as Lambda, Step Functions and Serverless Postgres. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Work in Progress: Implementing PEP 458 to Secure PyPI downloads - presented by Kairo de Araujo, Lukas Pühringer [Liffey B on 2022-07-15] Attacks on software repositories are extremely common and can have a vast impact. A single successful compromise of the content distribution infrastructure can affect millions of users, voluntarily installing the infected packages. PEP 458 (https://peps.python.org/pep-0458/) was designed to protect PyPI against a variety of possible attacks on PyPIs own content distribution network and PyPI mirrors, while giving administrators a mechanism to recover from a compromise if it happens. In addition, PEP 458 is a fundamental stepping stone for more advanced protection described in PEP 480 (https://peps.python.org/pep-0480/). Both PEP 458 and 480 implement a specification called ""The Update Framework"" (TUF) (http://theupdateframework.io/), which introduces a series of roles, keys and metadata formats that are published along with the packages they protect, and can be verified by a client software such as pip. Over the past couple of months we have made an effort to integrate the latest version of the Python TUF reference implementation with PyPI/Warehouse; see draft PR (https://github.com/pypa/warehouse/pull/10870). In this talk we will give an introduction to PEP 458 and TUF, how it works and what it is good for. We will report from the work-in-progress integration with Warehouse, what challenges we face and how Python developer and user workflows are affected, as well as an expected timeline for the integration. And last but not least, we want to give an outlook of what comes after PEP 458, that is full developer-to-user end-to-end protection of Python packages as described by PEP 480. With our talk we also hope to spark interest in software supply chain security and to encourage the community to get involved by reviewing, commenting and contributing to the PEP 458 and PEP 480 integration efforts. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Tales of Python Security - presented by Steve Dower [Liffey B on 2022-07-15] In this session, you'll learn about recent security issues in CPython and the core parts of our ecosystem. You'll hear about the process by which they were filed, how they were reviewed, analysed, shared (when appropriate), resolved and ultimately disclosed to the public. As well as real stories of security vulnerabilities, you'll learn how you can help by responsibly reporting potential issues, and how to protect yourself against common risks, as well as the best ways to find out about major issues and how to respond. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Python for Arts, Humanities and Social Sciences - presented by Arjumand Younus, Dr. Muhammad Atif Qureshi [Liffey A on 2022-07-15] The various areas within humanities and social sciences such as political science, sociology, psychology, economics etc. have evolved to a point where they have been complementing existing qualitative and quantitative methods with methods rooted in data science. This shift in paradigm is primarily driven by real-world, publicly available data sets that cover a variety of scholarly domains and have the potential to solve fundamental research questions in these intriguing fields. There is however a huge bottleneck to be overcome before realizing the full potential of data science in arts, humanities and social sciences; and that bottleneck relates to a fear of programming in students/researchers within these disciplines. Our talk presents some tips and tricks from course modules being taught in Technological University Dublin; the fundamental idea is to present an overview of data science toolkit and how it relates to problem solving in the real world. First we will present ways to make the data science lifecycle being made easy via tools such as Google colab and Jupyter notebooks followed by explaining how showing students the big picture and the workflow lifecycle of a data science technique helps grasps concepts in a very effective manner. We will present examples from exploratory data analysis and classification using data-driven research questions; and look into elegant solutions that can easily be plugged into a social scientist’s skillset. Examples of continuous assessment projects based on different Python libraries are also presented with a view to further establish use of Python as a valuable tool for arts, humanities, and social sciences. Finally, we will give an overview of an Irish research council funded project emanating from a combination of STEM and HUMANIITIES disciplines that aims to perform an economic assessment of anti-immigrant sentiment in Ireland. Various phases of the project will be explained emphasizing particularly those where Python tools play a major role in interpretion of research outcomes. These research outcomes obtained through smart use of Python data analytic tools play a key role in building relationships between data scientists and policy makers in both government and not-for-profit sector. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Automated Refactoring Large Python Codebases - presented by Jimmy Lai [Liffey A on 2022-07-15] Like many companies with multi-million-line Python codebases, Carta has struggled to adopt best practices like Black formatting and type annotation. The extra work needed to do the right thing competes with the almost overwhelming need for new development, and unclear code ownership and lack of insight into the size and scope of type problems add to the burden. We’ve greatly mitigated these problems by building an automated refactoring pipeline that applies Black formatting and backfills missing types via incremental Github pull requests. Our refactor applications use LibCST and MonkeyType to modify the Python syntax tree and use GitPython/PyGithub to create and manage pull requests. It divides changes into small, easily reviewed pull requests and assigns appropriate code owners to review them. After creating and merging more than 3,000 pull requests, we have fully converted our large codebase to Black format and have added type annotations to more than 50,000 functions. In this talk, you’ll learn to use LibCST to build automated refactoring tools that fix general Python code quality issues at scale and how to use GitPython/PyGithub to automate the code review process. Slides: https://www.slideshare.net/jimmy_lai/europython-2022-automated-refactoring-large-python-codebases This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Packaging security with Nix - presented by Ryan Lahfa [Liffey A on 2022-07-15] Managing securely dependencies is becoming an increasing concern of the industry. Here, we showcase how Nix, a functional-oriented package manager, can get us very far and close class of vulnerabilities that PyPI / pip had in the past, e.g. rogue PyPI packages that steals personal data. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Clean Architectures in Python - presented by Leonardo Giordani [Liffey A on 2022-07-15] Architectural considerations are often overlooked by developers or completely delegated to a framework. We should start once again discussing how applications are structured, how components are connected and how to lower coupling between different parts of a system, to avoid creating software that cannot easily be maintained or changed. The ""clean architecture"" model predates Robert Martin, who recently brought it back to the attention of the community, and is a way of structuring applications that leverages layers separation and internal APIs to achieve a very tidy, fully-tested, and loosely coupled system. The talk introduces the main ideas of the architecture, showing how the layers can be implemented in Python, following the content of the book ""Clean Architectures in Python"" edited by Leanpub. The book recently reached 25,000 downloads and many readers found it useful to start learning how to test software and how to structure an application without relying entirely on the framework. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Why is it slow? Strategies for solving performance problems - presented by Caleb Hattingh [Liffey A on 2022-07-15] You have a performance problem, and you don't know what to do. All you know is that one of your endpoints or applications is too slow; and perhaps it only affects a certain user or customer. How do you figure out why it's slow, and what can you do to catch performance problems before they hurt users in production? We'll go through a wide range of strategies for detecting and diagnosing performance problems in typical production workloads. We'll cover both web-based domains as well as backend domains and other analytical applications involving number-crunching and big-data applications. We'll step through the following high-level strategies: - Tracing: through instrumentation of your code, you will get detailed traces of where the time is spent in generating your web server responses. - Profiling: we'll look at profiling strategies using both the Python built-in cProfile tool, as well as awesome 3rd party libraries like pyspy, including how to use these with pytest - Isolation: how to figure out if performance is affected by CPU, or memory, disk, or network IO limitations. - Reasoning: we'll look at common scenarios that result in performance regressions such as the needless execution of sub-queries in rendering web views, or algorithmic analysis and ""big-O"" notation, or concurrency problems resulting from exhaustion of threads in a pool and asyncio concurrency limitations resulting from overloaded subscription. - Prophylaxis: we'll look at how to include benchmarks within your CI pipeline, including with pytest and other technologies to catch performance regressions ahead of time. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - How a popular MMORPG made me a better developer - presented by Valerie Shoskes [Wicklow Hall 1 on 2022-07-15] This talk will have special meaning for Final Fantasy fans, but anyone with nerdy non-coding hobbies should be able to enjoy it. The intended outcome is for attendees to see their own hobbies in a new light, where they can find their own abstract lessons. MMO gaming is becoming a more mainstream hobby, and as a lifelong gamer, I have plenty of experiences and stories to share on how the genre helped my transformation from a shy bundle of nerves to a confident professional. I also have experience applying my problem solving skills from software development into solutions for the community to combat problems that arose within the game. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Write Docs Devs Love: Ten Tricks To Level Up Your Tech Writing - presented by Mason Egger [Wicklow Hall 1 on 2022-07-15] Think of that feeling you get when you follow an online tutorial or documentation and the code works on the first run. Now think of all the hours spent wasted following broken, outdated, or incomplete documentation. From our favorite tutorials to bad product docs we all consume technical writing. Tutorials, blog posts, and product docs help developers learn new things, build projects, and debug issues. But what makes one tutorial better than another? In this talk I'll discuss how you can write the documentation that developers love and I’ll share 10 tips and tricks to improve your technical writing. Outline * Introduction (1 min) * Why is Technical Writing Important? (4 min) * My Top 10 Tips to improve your Technical Writing (20 min) * # 10 - Make Your End Goal Clear * # 9 - Don’t Be Overly Verbose * # 8 - Inclusive Language * Avoid words like Simple, Easy * # 7 - Avoid Technical Jargon * # 6 - Define ALL Acronyms * # 5 - Avoid Memes/Colloquialisms * # 4 - Use Meaningful Code Samples and Variable Names * # 3 - Don’t Make Your Reader Leave Your Article * # 2 - Make it Easy for the Reader to Find a Single Piece of Information * # 1 - Verify Your Instructions! Test, Test, Test! * # 0 Bonus! - Practice, Practice, Practice * How You Can Get Started in Technical Writing (3 min) * Conclusion & Questions (2 min) This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Dr. Jekyll & Mr. Hyde - transition from developer to manager without going crazy or becoming evil - presented by Jakub Paczkowski [Wicklow Hall 1 on 2022-07-15] You've been a developer for a couple of years already. Your journey started as an intern/junior-level position where you were learning to code; then, going through mid and senior positions, you were offered the team lead or even engineering manager role. At this moment, you have plenty of questions and doubts. How to answer them to make sure you make a good decision? How to prepare for the new role if you want to take it? I'll help you answer these questions and prepare for your future role." This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Leading & growing software teams - presented by Radoslav Georgiev [Wicklow Hall 1 on 2022-07-15] Software development is a team game. As you progress through your career, you might end up in a leadership role, taking care of your own team, or even of multiple teams. As a team lead, it’s up to you to establish a good working rhythm, set the right expectations, communicate up and down the chain of command and effectively help your team grow in both technical and non-technical terms. As a team lead, you want to enable your team to reach its full potential. The main goal of this talk is to provide pragmatic real-life examples, about how to achieve those things. We are going to cover the following topics: 1. What’s the role of a team lead? 2. Managing expectations & responsibilities. 3. Establishing a good work rhythm. 4. Establishing a good form of communication. 5. What does team growth look like? This talk is the natural sequel of the following talks from previous EuroPythons: - EuroPython 2017 - Practical Debugging - Tips, Tricks and Ways to think - https://www.youtube.com/watch?v=9Ys4gCUtTh8 - EuroPython 2018 - Django structure for scale and longevity - https://www.youtube.com/watch?v=yG3ZdxBb1oo - EuroPython 2019 - Software patterns for productive teams - https://www.youtube.com/watch?v=fEy68VRmOeQ" This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Best practices to open source a product and creating a community around it - presented by Adrin Jalali [Wicklow Hall 1 on 2022-07-15] There are many aspects of open sourcing a product which are often overlooked yet greatly impact the community and activities around the project. One of the first things people think about is the licence [1], which is very important, but what people don’t often think about is the governance of it, which impacts the speed, decision making processes, and the kind of engagement one can get from contributors to the project who don’t work in the company. Not every project is open sourced for the same purpose. On one side of the “openness” spectrum some projects are out there to give a bit of visibility to what a team is doing or to showcase a research or another product, and on the other spectrum the creators of a project put it out there to create a user and contributing community so that eventually the community would be active enough for the original creators to become a minority in the contributing and governance team. Depending on what the goals are, one needs to create or use a governance model which matches those goals and needs. One can look at the following categories from this perspective [2]: - ""Do-ocracy"" - Founder-leader - Self-appointing council or board - Electoral - Corporate-backed - Foundation-backed Then we talk about some practices which can fend people off when they try to join a community, giving concrete detailed examples on how it can look like while interacting with contributors and users online, such as [3]: - Lack of onboarding - Nothing in writing - Leadership is a mystery - No path to success - Poor communication - Lack of transparency - Not seeing ourselves in others [1] Licences and Standards, https://opensource.org/licenses [2] Understanding open source governance models, https://www.redhat.com/en/blog/understanding-open-source-governance-models [3] Brain Proffitt, Seven Deadly Sins of Open Source Communities" This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - What transitioning from male to female taught me about leadership - presented by Ivett Ördög [Wicklow Hall 1 on 2022-07-15] I’ve been struggling with gender dysphoria (a debilitating sense of disconnect from the gender assigned to someone at birth) for decades, but it took me until not so long ago to realize what it was, and how it could be treated. Nothing has been the same since. Transitioning and the events leading up to it changed my life, and the experiences I had during my transition changed me as a person, and as a leader. It’s hard for me to open up about this period in my life, not just because it comes with tremendous vulnerability, not just because it’s very personal, but also because it has been the hardest few months in my life. The decisions I faced were far more consequential and way harder to grapple than any decisions I had to make as a leader or any time during my professional career. However I feel that other people — people who will never go through anything like I did — can learn from my story a lot exactly because it has been a very unusual and difficult problem to solve." This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - EuroPython 2022 Closing Session [The Auditorium on 2022-07-15] See you at EuroPython 2023! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Friday Lightning Talks [The Auditorium on 2022-07-15] Signing up is on a first-come-first-served basis. The queue is reset every day in the morning. You may talk about / present (almost) everything with certain boundaries: - no promotion for products of companies, no call for 'we are hiring' (but you may name your employer). - conference announcements are limited to one minute only - one LT per person per conference policy: everyone who has not given an LT at this year's conference, yet, is ahead of you in the queue - keep it short, the shorter the presentations, the more people can give a talk See you there and have fun! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Demystifying Python’s Internals: Diving into CPython by implementing a pipe operator - presented by Sebastiaan Zeeff [The Auditorium on 2022-07-15] Diving into the CPython source code can feel daunting. Whether you want to start contributing or just want to get a better understanding of Python by exploring its source code, it’s often difficult to know where to start or what you’re missing. In my talk, I will show you around the CPython source code by implementing a new operator, a pipe operator. While doing so, I will discuss core parts of the internals, such as Python’s grammar, its syntax trees, and the underlying logic that will perform the operation. By the end, you will have a good idea of the moving parts involved in core language features. I will also take you through the steps necessary to make it all work. I’ll show you how I obtained a copy of the source code, regenerated the parser and token files, and how I compiled my modified version of CPython. I will also write and run tests to help me implement my changes. This should give you a mental framework that helps you while diving into more comprehensive resources, like the excellent Python Developer’s Guide (https://devguide.python.org/). My talk is aimed at everyone who wants to explore CPython’s internals. You don’t have to be an expert in Python, although some affinity with Python helps with understanding the internals. I will also use C to implement some of the operator logic, but knowledge of C is by no means required. In short, if you’re interested in diving into the CPython source code, this talk is for you. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Education Panel - presented by Chris Reina, Kelly Schuster - Paredes, Aimée Fagan, Keith Quille & Sarah-Jayne Carey [The Auditorium on 2022-07-15] Teaching Python: a panel discussion with perspectives from teachers, academics, makers and enthusiasts. Why is Python appealing in education? What tools and resources work well? What can the Python community do to help teachers & policy makers? Join us for an engaging and insightful discussion with a fascinating panel of experts, Dr Keith Quille, Kelly Schuster-Paredes, Chris Reina and Sarah-Jayne Carey. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Game Development with CircuitPython - presented by Radomir Dopieralski [The Auditorium on 2022-07-15] Making games on small devices is great fun and also a great way to learn. You don't have to worry about breaking anything, and the games tend to be much simpler than on the big computers. And with CircuitPython you don't need to install anything on your computer, all you need is a text editor. But it's not easy to decide what you need exactly: what hardware to get, which libraries to use and how to actually put it all together to spend the minimum time on all that, and maximum time on the game itself? I'm going to go over the available options, their pros and cons, and show some examples to get you started. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Super Search with OpenSearch and Python - presented by Laysa Uchoa [The Auditorium on 2022-07-15] OpenSearch is an open source and free document database with search and aggregation superpowers, based on Elasticsearch. This session covers how to use OpenSearch to perform both simple and advanced searches on semi-structured data such as a product database. Search is pretty useful inside applications, so we'll also discuss how to connect to OpenSearch from existing Python applications, work with data in the database, and perform search and aggregation queries from Python. This talk is recommended for Python developers whose applications are ready to gain some search superpowers. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - `typing.Protocol`: type hints as Guido intended - presented by Luciano Ramalho [The Auditorium on 2022-07-15] Duck typing and static typing are not opposites. Go is a successful statically checked language with support for duck typing through interfaces that work like `typing.Protocol` does. A `Protocol` subclass defines an interface that past and future classes can implement without any coupling to the interface: they simply provide the required methods. That's statically checked duck typing: a powerful combination! In this talk we'll get back to basics looking at how duck typing is used in Python since the beginning, how `__dunder__` methods leverage that idea to support what we recognize as *Pythonic* code. Then we'll see how `typing.Protocol` fills the gap in the original PEP 484—Type Hints, and finally lets us properly annotate code that leverages the flexibility and loose coupling of duck typing. Finally, we'll look at the experience of the Go community to learn what makes a good Protocol. Spoiler alert: your favorite Python ABC may not be the basis of a useful Protocol! This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/

EuroPython 2022 - Keynote: Multithreaded Python without the GIL - presented by Sam Gross [The Auditorium on 2022-07-15] CPython’s “Global Interpreter Lock”, or “GIL”, prevents multiple threads from executing Python code in parallel. The GIL was added to Python in 1992 together with the original support for threads in order to protect access to the interpreter’s shared state. Python supports a number of ways to enable parallelism within the constraints of the GIL, but they come with significant limitations. Imagine if you could avoid the startup time of joblib workers, the multiprocess instability of PyTorch’s DataLoaders, and the overhead of pickling data for inter-process communication. The “nogil” project aims to remove the GIL from CPython to make multithreaded Python programs more efficient, while maintaining backward compatibility and single-threaded performance. It exists as a fork, but the eventual goal is to contribute these changes upstream. This talk will cover the changes to Python to let it run efficiently without the GIL and what these changes mean for Python programmers and extension authors. This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License http://creativecommons.org/licenses/by-nc-sa/4.0/