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.

Learn how to create viral Machine Learning demos with Python

Omar Sanseviero

How to craft awesome Machine Learning demos with Python

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.

PySnooper: Never use print for debugging again. Learn about an indispensable tool for finding bugs in your Python code.

Ram Rachum

PySnooper: Never use print for debugging again

To ensure quality, automated testing is a must. But sometimes is impossible or very expensive to use real environments. In this case, you can isolate some parts of a system and use fake simulated objects.

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 develop

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.

María Andrea Vignau

Dance with shadows: stubs, patch and mock

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.

Python Protocols - Structural subtyping for decoupled and Pythonic code

Outline

- What are protocols:
   - Structural vs nominal typing
   - Static duck typing
   - Difference between ABCs and protocols

- Examples
    - Simple example
    - Extending protocols

- Use cases
    - Dynamically typed code
    - Library types

During this talk we will go over Protocols and how they can be employed to achieve better code. Take the following code snippet as an example:

```python
from typing import Sized, Iterable, Iterator

class Bucket(Sized, Iterable[int]):
    ...
    def __len__(self) -> int: ...
    def __iter__(self) -> Iterator[int]: ...
```

The problem here is that you must explicitly inherit these bases classes to register them as subtypes of their parents.

This is particularly difficult to do with library types as the type objects may be hidden deep in the implementation of the library. Also, extensive use of ABCs might impose additional runtime costs.

Consider the following snippet as a solution:

```python
from typing import Iterator, Iterable

class Bucket:
    ...
    def __len__(self) -> int: ...
    def __iter__(self) -> Iterator[int]: ...

def collect(items: Iterable[int]) -> int: ...
result: int = collect(Bucket())  # Passes type check
```

Protocols enable you to pass static type checking implicitly.

Ran Zvi

Protocols - Static duck typing for decoupled code

There are over 70 000 different Lego bricks and they appear in almost 200 different colors. Even the most hardcore AFOLs (Adult Fan of Lego) don’t know all of them. Let alone be able to recognize them. So I got curious whether it’s possible to create an application that can recognize the particular brick using only its photo.

Building an app that recognizes 70 000 different Lego bricks!

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.

Piotr Rybak

Classifying LEGO Bricks with Machine Learning

Implementing complex systems with microservices can be a great decision, but if we’re not careful we can end up with a distributed monolith. Let’s see how to avoid that by building lightweight, loosely coupled microservices using Python, Flask, and Apache Kafka.

Come and learn how Python and Apache Kafka give us the tools we need to build scalable and extensible microservices!

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.

Dave Klein

Event-driven microservices with Python and Apache Kafka

If you try to use Pylint or Flake8 on a legacy project, the results are usually truly overwhelming. There might be thousands of warnings, hundreds of errors and maybe even no unit tests. 
The usual emotional response to this is distress, exasperation... even despair. And then the question comes: *Where do I start?*

During this talk we will see why it’s better to set old code aside and focus first on the new code you’re writing. We’ll show some possible approaches and tools that can help you keep the focus and deliver new code with a high level of quality.

If you try to use Pylint or Flake8 on a legacy project, the results are usually truly overwhelming. How to deal with all these thousands of warnings and errors? Leave the past behind, focus on new code!

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*.
### 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.

### Why *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

### 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)

Andrea Guarino

Managing the code quality of your project. Leave the past behind: Focus on new code.

Pandas is the first Python library that I learned to use. It is used by data scientists to manage, transform and inspect data. As more and more open-source tools appear, it seems the spotlight has shifted and I would love to shine some light on this tool that all should know.

Pandas is the first Python library that I learned to use. It is used by data scientists to manage, transform and inspect data. I would love to shine some light on this tool that all should know.

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.

Cheuk Ting Ho

I have to Confess, I still Love Pandas

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.

Protocols in Python: Why You Need Them - 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?

Rogier van der Geer

Protocols in Python: Why You Need Them

A place to come and talk about the geometry of the universe.

Sagittarius A* and where is the Sun?

gamma ray bursts

gravitational waves.

What will James Webb see?

How to test different models?

Python, matplotlib, scipy, astropy

units and constants.   Hubble and c

But maybe Hubble's not constant?

From Einstein and Fred Hoyle to the James Webb telescope and beyond.

John Gill

The Geometry of the Universe

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.

Improve your error handling with Error Groups, a new feature introduced in Python 3.11

Or Chen

Raise better errors with Exception Groups

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.

Panel Panel Panel Panel Panel Panel Panel Panel Panel Panel Panel Panel Panel Panel Panel Panel Panel

How to craft awesome Machine Learning demos with Python

Abstract

The speaker