One of the many strengths of python is PyPI, which complements and enhances the "batteries included" approach of the standard library. Building a library, and publishing it to PyPI has a number of challenges, pitfalls, and choices that someone has to make. In this talk, I would share my journey from v0.1.0 to v1.0.0 and all the moments that I said: "I wish I knew this thing before".

The decisions made during the journey of a Python library from v0.1.0 to v1.0.0

This talk is about all the mistakes that I made while building a library, how I would have avoided making them if I started today, what turns I would have taken differently, what choices I made, and why I made them. Examples are drawn from the building of a specific library, but it's not about a specific one. 

The aim is to give some insights more into how to make choices when building a library available to the world, and less on the specific set of choices that I made.

It will not be technically challenging, but some familiarity with the Python ecosystem is advised.

Stephanos

Lessons learnt from building my own library

Jupyter notebooks are great to quickly try new ideas and experiments, but the downside is that using code to change inputs and see the results can be inefficient and error-prone. ipywidget is a Python library that solves this problem by providing a user-friendly interface with iterative widgets. It's all in Python so we don't have to worry with any CSS or Javascript. In this talk we'll learn how ipywidgets can help us build tools in the context of Data Science.

ipywidget is a library that provides a user-friendly interface with iterative input widgets. It's all in Python so we don't have to worry with any CSS or Javascript. In this talk we'll learn how ipywidgets can help us build tools in the context of Data Science

A useful Jupyter notebook that takes input from the user to generate results is a great candidate to become a web application, but usually data scientists don't have the front-end skills required to build one and deploy them. Using notebooks with ipywidgets can be a great solution to build teams' internal tools because we get the user-friendly widgets and don't need to worry about the deployment since it's all in Jupyter.

Deborah Mesquita

Creating great user interfaces on Jupyter Notebooks with ipywidgets

The use of transfer learning has begun a golden era in applications of Machine Learning but the development of these models “democratically” is still in the dark ages compared to best practices in Software Engineering. I describe how methods of open-source software development can allow models to be built by a distributed community of researchers.

The use of transfer learning has begun a golden era in applications of Machine Learning but the development of these models “democratically” is still in the dark ages compared to best practices in Software Engineering. I describe how methods of open-source sof

Here, I elaborate on why we should develop tools that will allow us to build pre-trained models in the same way that we build open-source software. Specifically, models should be developed by a large community of stakeholders who continually update and improve them. Realizing this goal will require porting many ideas from open-source software development to building and training models, which motivates many threads of interesting research and opens up machine learning research for much larger participation.

Steven Kolawole

Open Science: Building Models LIke We Build Open-Source Software

Code that’s uniform is easier to read, write, and debug, but writing down your standards and conventions in a README that no one reads isn’t enough. The explosion of CI and linter tools allow you to no only document your standards and conventions, but make sure people actually adhere to them.

The explosion of CI and linter tools allow you to no only document your standards and conventions, but make sure people actually adhere to them using linters!

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

Luke Lee

Lint All the Things!

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

HTTP proxies are not dead! MASQUE protects your privacy by onion routing through HTTP/3 proxies. Can Python HTTP clients support that?

Miloslav Pojman

How I wrote a Python client for HTTP/3 proxies

To mash up various APIs, data need to have a well defined meaning: imagine meshing up healthcare APIs using different units for human temperature, or financial APIs using different currencies.

This talk describes strategies and python tools to overcome these problems in large API ecosystems such as data exchanges between different countries.

Strategies and tools to ease API mash ups in large API ecosystems.

This talk will present strategies and python tools to create semantically interoperable REST APIs. After the problem statement, various solutions will be presented, including:

* contract-first api development with OpenAPI 3, ontologies and controlled vocabularies like the ones [published by the European Union](https://op.europa.eu/en/web/eu-vocabularies/authority-tables);
* the rdflib and pyld python libraries for processing json-ld and [RDF files](https://en.wikipedia.org/wiki/Resource_Description_Framework);
* the use of centralized catalogs such as [schema.org](schema.org).

Prerequisites:

* no prior knowledge of semantics and ontologies;
* practical experience with OpenAPI, json schema and data modeling and API design in general.

Roberto Polli

Self-explaining APIs

What if we can have a tool that helps us to do intelligent load balancing or What if we can do selective compression of the data and extremely fast and light weight transfer of data? Then let me introduce gRPC, the technology that helps us to do all of this and how can we integrate gRPC with Python.

What if we can have a tool that helps us to do intelligent load balancing or What if we can do selective compression of the data and extremely fast and light weight transfer of data? Then let me introduce gRPC, the technology that helps us to do all of this.

gRPC is one of the most new breakthroughs in the world of client server interaction. Using gRPC our client can directly make a call to a server on a different machine as if it were a local object. gRPC has low latency, high scalability and supports multiple use cases for distributed system. We can even build mobile clients which can communicate to a cloud server. gRPC uses Protocol Buffers which is an open source mechanism for serialising structured data, which makes payloads faster, smaller and simpler. In this talk we will try to understand how can we get started with gRPC in Python. grpcio package of python will be used for the demonstration of the examples and we will cover basics of gRPC as well. We will build a basic gRPC service and define protocol buffers for it. Demonstration of how a client and a server can be made through gRPC and how can they communicate.

Sanket Singh

When gRPC met Python

The talk focuses on establishing guidelines for Explainable AI by diving into fundamental concepts and checkpoints, before accepting AI models to make decisions. We go through explainers, types, and algorithms with a simple implementation in Python, to strengthen our understanding of "WHY?" the model predicts a certain value and "HOW?" to validate it with experiential learning of experts to bridge potential gaps

Caution : AI can backfire without a harmonious integration with Domain Expertise

We will go through the Why? How? and What? of Model Explainability to build consistent, robust and trustworthy models. We explore the inability of complex models to deliver meaningful insights, cause-effect relationships and inter-connected effects within data and how explainers can empower decision makers with more than just predictions. We evaluate an intuitive game-theory based algorithm, SHAP, with a working implementation in Python. We will also pin-point intersections necessary with domain experts with 2 practical industry applications to facilitate further exploration.

Pranjal Biyani

Synergize AI and Domain Expertise - Explainability Check with Python

By using Streamlit and streamlit-webrtc, we can create web-based real-time computer vision apps only with ~10 or 20 additional lines of Python code.

To turn computer vision models into real-time demos, we have conventionally used OpenCV modules such as `cv2.VideoCapture` and `cv2.imshow()`. However, such apps are difficult or impossible to share with friends, run on smartphones, or integrate with modern interactive widgets and other data views and inputs.

Web-based apps don't have such problems.

Streamlit provides an easy way to build web apps quickly, and `streamlit-webrtc` allows to use real-time video streams.
You can create real-time video apps with modern interactive views and inputs, and host these apps on the cloud to use from any devices with browsers.

In this talk, I will demonstrate the development process using these libraries and show a variety of examples so that we see how easy and useful they are and can make use of them in daily development and research.`streamlit-webrtc` extends Streamlit to be capable of dealing with real-time video and audio streams.
With a combination of these libraries, developers can rapidly create real-time computer vision and audio processing apps for which OpenCV has typically been used.

Streamlit and streamlit-webrtc provide a new easy way to turn computer vision models into real-time web-based apps. They have some advantages over the conventional ways which use OpenCV.

I am the author of `streamlit-webrtc` and a member of [the Streamlit Creators program](https://streamlit.io/creators) (selected community members).
The repository of `streamlit-webrtc` is here: https://github.com/whitphx/streamlit-webrtc

My lightning talk about `streamlit-webrtc` at PyCon JP 2021 is available: https://youtu.be/_LuLs8H1gJc

Articles about this library:

* [Developing Web-Based Real-Time Video/Audio Processing Apps Quickly with Streamlit](https://towardsdatascience.com/developing-web-based-real-time-video-audio-processing-apps-quickly-with-streamlit-7c7bcd0bc5a8)
* [Real-Time Video Streams With Streamlit-WebRTC](https://betterprogramming.pub/real-time-video-streams-with-streamlit-webrtc-bd38d15f2ef3)

As linked from the repo, demo apps I have developed are available online:

* Demo showcase including real-time object detection: https://share.streamlit.io/whitphx/streamlit-webrtc-example/main/app.py
  * Source code: https://github.com/whitphx/streamlit-webrtc-example/blob/main/app.py
* Real-time Speech-to-Text: https://share.streamlit.io/whitphx/streamlit-stt-app/main/app_deepspeech.py
  * Source code: https://github.com/whitphx/streamlit-stt-app
* Real-time style transfer: https://share.streamlit.io/whitphx/style-transfer-web-app/main/app.py
  * Source code: https://share.streamlit.io/whitphx/style-transfer-web-app/main/app.py
* Real-time Tokyo 2020 Pictogram: https://share.streamlit.io/whitphx/tokyo2020-pictogram-using-mediapipe/streamlit-app
  * Source code: https://github.com/whitphx/Tokyo2020-Pictogram-using-MediaPipe
* Video chat: online demo is not available because it does not have an auth mechanism and is only for private use.
  * Source code: https://github.com/whitphx/streamlit-video-chat-example

Yuichiro Tachibana

Real-time browser-ready computer vision apps with Streamlit

Come meet some of the folks working on Diversity and Inclusion in the global Python Community!
Join the live panel discussion to hear about the challenges and the work they do.

With Marlene Mhangami, Nabanita Roy, Iqbal Abdullah, Tereza Iofciu. Chaired by Naomi Ceder.

Come meet some of the folks working on Diversity and Inclusion in the global Python Community! Join the live panel discussion to hear about the challenges and the work they do.

Tereza Iofciu

Marlene Mhangami

Naomi Ceder

Nabanita Roy

Iqbal Abdullah

Diversity & Inclusion in the Python Community Panel

Why should you care about your personal brand? After all, it’s not like you are an actor or the lead singer for a rock band. In fact, it’s never been more important for you to think about yourself as a brand. Doing so will provide rocket fuel for your career. You’ll find better jobs and become a  “thought leader” in your industry. You’ll become known for your expertise and leadership; people will seek your advice and point of view. As a developer, there are many tools you can use to build a personal brand, and this presentation will help you learn how to get visibility, make a real impact, and achieve your goals. You don’t need to be a marketing expert or a personal branding guru— you can be yourself and get your dream job or reach the next level of your career.

What the heck is Personal Branding? Why should I care about it? Surprise, you already have one!  Get answers to your questions, and learn how to take the ownership of your own personal branding to be even more successful in your career with @fharper 🎯

Lessons learnt from building my own library

Abstract

Description

The speaker