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

Today, there are many tasks to repeat in the company/community.
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.

In this talk, I will first explain how to create a chatbot using Bolt for Python. 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.

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.

Takanori Suzuki

Automate the Boring Stuff with Slackbot(ver.2)

I have been programming in Python for 5 years and almost from day one I've been using Docker with Python. Docker is now a widely used tool across the industry, due to its flexibility. It can be used as a tool to help deploy your code in production, say using Kubernetes. It can also be used as a tool to help develop code locally, with tools such as docker-compose.

It has taken me some time to discover various features and best practices when using Docker. Especially when it comes to using it for local development.

In this talk, I would like to go over a journey I have taken with Docker whilst working with it over several years. Starting from a single build step with a full-fat image, going over multi-stage Docker images. Showing you how you can use the same Dockerfile for development and production.

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.

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 CRUD 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 (using Makefiles)
  - How to use this with Github Action
- Then look at multistage builds briefly
   - Then split this into development and production image
 - Finally, look at using Poetry to manage our dependencies
   -  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.

Haseeb Majid

My journey using Docker as a development tool

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.

HPy is a new C API for Python. Unlike the standard one, it isn't tied to CPython implementation details. It is therefore fully compatible with alternate implementations and with any future changes to CPython itself.

Ronan Lamy

HPy: a better C API for Python

All one needs is strategy, skill and resources to make digitalization and AI happen. So why is everything taking so long? Shouldn’t you all be finished yesterday already? An honest talk about how to address the complexity of making AI happen in enterprises.

All one needs is strategy, skill and resources to make digitalization and AI happen. So why is everything taking so long? Shouldn’t you all be finished yesterday already?

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

Alexander CS Hendorf

Making AI Happen at Your Company

What if I told you you could write simpler tests but still get better results ? 

What if I told you can automatically generate your test data ?

This may sound difficult to your traditional testing approach but can be easily done with property-based testing. 

Property-based testing allows a range of inputs to be tested on a given aspect of a software property, abstracting away the details.

In the world of Python you can accomplish this with Hypothesis, the Python library used for property-based testing. 

Hypothesis helps you design cleaner and clever test suites.

Design cleaner and clever test suites with Hypothesis, the Python library used for property-based testing.

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.

Emma Saroyan

Property-based testing the Python way

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, decide whether to load it, and then keep track of it in memory? In this talk, I'll walk you through what happens when you "import" a module into Python, revealing the complexities of something seemingly simple that we use every day.

What happens when you import a module in Python? Let's pull back the curtain and find out!

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.

Reuven M. Lerner

What happens when you import a module?

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.
* A PEP idea for making debuggers easier to debug.

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

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.

Classifying LEGO Bricks with Machine Learning

Abstract

Description

The speaker