Confirmed sessions#

Target Audience:

• Pythonistas with a penchant for puns and conquering the mundane with code.
• Aspiring IoT alchemists seeking to turn sensor readings into automated gold (or at least, uninterrupted sleep).
• Anyone who enjoys learning through laughter and the occasional “print(‘facepalm’)“.

Benefits for Attendees:

• Gain practical knowledge of MQTT and its Pythonic potential.
• Learn to craft multi-layered solutions that combine sensors, user control, and API integration.
• Embrace the iterative nature of development and learn to laugh at your code (trust me, it helps).

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

We live in times that have quite a lot of those science facts- even if hoverboards sadly are not part of them- and now have to deal with this new world and all it’s changes for better or for worse. There are unsettling deepfakes, stunning Cap-Set-Problem-solving language models and the question of artificial conscience. Developers might be able to navigate the turbulences of AI evolution, but are you brave enough to take on the quest of untangling the nebulous scriptures of law that are known to the chaotic neutral wordwizards of the council of Europa as the „AI Act“?

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

The Proposal for the European Artificial Intelligence Act takes 272 Pages of legalese to work through. This talk will give a short overview of what the European AI Act is and about the purpose and necessity of a globally harmonised legal system. Hopefully it will give an understanding about the main goals of the act, which are, spoiler alert, ensuring AI safety, the protection of fundamental rights, and legal clarity for businesses and developers (which is probably you). Let us discuss, how developers can shield fundamental rights by writing ethical AI Systems whilst navigating the regulatory landscape and staying tuned with legal development as well.

Large Language Models (LLMs) are still relatively new compared to ""Traditional ML"" techniques and have many new ideas as best practises that differ from training ML models.

In this workshop, you will learn the tips and tricks of creating and fine-tuning LLMs along with implementing cutting edge ideas of building these systems from the best research papers.

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

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

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

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

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

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

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

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

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

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

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

We’ll start simple and build from there:

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

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

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

Spoiler:

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

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

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

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

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

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

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

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

Aspiring Kubernetes enthusiasts will gain insights into leveraging Python for tasks such as cluster configuration, application deployment and resource management.

This presentation serves as a comprehensive introduction for beginners, equipping them with the essential skills to navigate and harness the capabilities of Kubernetes using the Python programming language. From setting up your first cluster to deploying applications seamlessly, join us for a hands-on exploration of Kubernetes with Python.

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

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

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

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

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

Fast-forward to the present, where the issue of not “building the right thing” crops up all over software development. There are a whole host of reasons we may not end up delivering what our user, stakeholder or team actually needs from us.

In this talk, I’ll help you make sure that whatever you create is valuable - or at the very least, Nobel Prize-winning.

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

About AsyncAPI#

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

About FastStream#

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

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

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

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

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

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

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

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

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

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

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

Target audience#

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

Goal#

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

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

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

Tutorial Requirements:

• Attendees should have some familiarity with Jupyter Notebooks and/or JupyterLab.
• Attendees must have solid experience with any typical object-oriented programming language (i.e. a good understanding of classes, objects, and inheritance).
• Attendees must have a laptop with miniconda installed and working. (conda, micromamba, or mamba environments also work). (See https://docs.conda.io/projects/miniconda/en/latest/miniconda-install.html )
• Not required, but helpful, if attendees can install the following environment before the tutorial:

    conda create -n jlx --override-channels --strict-channel-priority  \
        -c conda-forge -c nodefaults \
        jupyterlab=4 nodejs=18 git copier=7 jinja2-time

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

This talk will start off by looking at the subject from the users’ perspective:

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

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

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

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

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

You will learn how to:

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

You should possess:

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

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

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

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

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

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

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

Lets make Python ecosystem even more awesome!

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

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

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

Plan:

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

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

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

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

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

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

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

Key Takeaways:

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

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

• Identify what lies below the clouds in satellite imagery using the Generative Vision model.
• Perform Zero-Shot object detection in satellite images with human language input using Multimodals.
• Segment Roads, Vehicles, Buildings, etc., in a city using the Segmentation model.
• Obtain high-resolution satellite imagery from lower resolution using the SuperResolution model.

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

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

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

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

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

Outline#

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

Audience & Preparation#

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

Do make sure to bring your laptop, with the following tools installed:

• Python 3.12
• A container runtime (preferably Docker)
• Git
• Your favorite editor

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

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

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

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

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

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

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

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

The main three questions I’ll be asking are:

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

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

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

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

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

Expect to learn:

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

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

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

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

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

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

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

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

In particular the presentation will cover:

• Status and Short-Comings of our old Search
• Introduction of Hybrid Search
• Our Machine Learning Solution
• Architecture and Implementation (with special consideration of latency)
• Learnings and Next Steps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The talk will be inspiring and useful for anyone interested in AI/ML experimentation and portable, safe serialization of Python objects.

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

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

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

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

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

• How to collect data from YouTube? (5m) o reason for collecting data using YouTube o keywords to find videos o YouTube API
• How to transcribe audio to text? (5m) o Whisper API o how long it took o accuracy
• Semantic analysis of testimony (10m) o BERTopic o Analysis of relevant words
• How useful it is for analyzing unstructured data (10m)
• Conclusion (2m)

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

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

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

As developers, we have responsibility to ensure that our products serve everyone, regardless of their background or identity. However, our unconscious bias often creeps into even the most well-intentioned projects and impacts the way we develop products or engage with communities, leading to unintentional exclusions.

When I first designed a Speech-Text-Analytic app, my focus was to simplify business communication with transcribed audio and valuable insights. However, feedback from the community highlighted it had limitations for diverse users, including those with disabilities who faced inaccurate captions for audio content.

This wake-up call prompted me to improve accessibility and user-friendliness for marginalized groups. And for the same reason, I’m making proactive steps to cater for the marginalized by integrating a feature that recognizes Nigerian native languages.

As tech creators, we have the power to create change, but good intentions alone are not enough. This talk will offer strategies to address unconscious bias in product and community building, while avoiding common pitfalls. Attendees will learn to understand diverse needs & experiences for more inclusive environments.

However, when we encounter the term observability, our initial instinct is usually to attribute it solely to SRE concerns. Upon closer examination, one may realize that actually implementing observability is, in essence, more aligned with the developer domain. During this session, we will discuss the importance of observability and related challenges from a developer’s perspective. The discussion will cover typical architectures, ranging from the ease of instrumenting our Python code to further data processing and the seamless export of telemetry data for analysis. Attendees will gain a deeper understanding of the significance of observability and how integrating open-source frameworks like OpenTelemetry promotes effective observability in a vendor-neutral way.

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

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

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

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

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

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

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

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

• More than half simply read the code and find issues with their eyes;
• 10% don’t face such problems at all;
• The rest use various profilers.

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

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

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

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

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

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

• A new per-Interpreter GIL in Python 3.12 helps to facilitate true parallelism by opening up sub interpreters to run Python codes at the same time. In addition, it is going to be easier to use these features in Python 3.13 by having support for sub interpreters in the Stdlib.
• An upcoming compile option to disable-gil is opening a path to a world with NoGIL where Python threads can truly run in parallel. Which can potentially become the default in the upcoming years. Multiprocessing, sub-interpreters and multi-threading without GIL are all different ways of facilitating multi-core parallelism in Python. Each of these approaches offers a unique pathway to parallel execution, but comes with its own set of trade-offs, complexities, and suitability for different types of problems. During this talk we will explore each of these options and asses their pros and cons.

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

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

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

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

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

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

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

But what about building rapid prototypes and proof of concepts?

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

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

We’ll focus on topics like:

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

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

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

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

It turns out that Django is all we need.

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

redun’s key features are:

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

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

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

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

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

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

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

SPy tries to reconcile these two sides:

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

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

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

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

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

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

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

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

• Test Suite Execution Time: The duration of test suite execution escalated significantly as we added more tests over time, hampering development speed.
• Slow Test Startup: Complex test setup led to prolonged test startup times, impeding developer productivity.
• Test Coverage Reporting Overhead: Coverage tools introduced substantial overhead and impacted test performance.

Solutions Implemented:

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

Syft is an open source stack that provides secure and private Data Science in Python. Syft decouples private data from model training, using techniques like Federated Learning, and Encrypted Computation. Moreover, Syft provides a numpy-like interface to integrate with deep learning frameworks so that it is easier to replicate any existing workflows while using privacy-enhancing techniques.

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

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

This talk will describe how Apache Iceberg and Parquet are the dynamic duo of big data management, offering ACID transactions, time travel, and columnar storage capabilities that enable lightning-fast query performance and seamless schema evolution for even our largest workloads.

The session will introduce Apache Iceberg, an open-source table format that enables incremental updates, versioning, and schema evolution. The discussion will then focus on Parquet files, which store data in a compressed and columnar format to enhance query performance and lower storage costs. Finally, the session will outline how our Enterprise Data Lake Applications engineering team has harnessed the capabilities of Apache Iceberg (especially PyIceberg) to revolutionize our data management and analytical processing workflows.

Attendees will be able to apply the best practices discussed in the talk to build better infrastructure for their growing data demands and spur innovation within their organization.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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