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

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

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 🎯

Self-explaining APIs

Abstract

Description

The speaker