List of videos

Python web applications running in the browser or mobile without a Server? What seemed to be a dream just a few months ago is not possible thanks to PyScript. It is now possible to write websites, apps, and games running entirely on the browser. This Tutorial is an introduction to PyScript and will walk you through learning about basic concepts, how to set up your project and create amazing applications. More specifically: - Create your project configuration - Define a python environment with all the dependencies to run your code - Loading and manipulating with user data - Writing your python code - Accessing the DOM and other browser features - Using Javascript libraries from your Python application - Optimizing your application - Look at what’s different between “standard” python vs. Python on the browser - Have a lot of fun and hack together on your ideas!

Literate programming is a programming paradigm that incorporates explanations in natural language (such as Spanish) embedded with the traditional code. Literate programming allows developers to tell a story with their codes, improving the understanding of the project, focusing on documentation, and making it easier to onboard developers. Although being a very well-regarded concept discussed by respected researchers like Donald Knuth, literate programming tools like Jupyter notebooks are considered inefficient for serious software development. This perception has limited Jupyter notebooks to simple python scripts and educational materials. The Nbdev library has proven that literate programming is useful in developing big and serious projects, like FastAi. This tutorial will show attendees how to get the benefits of literate programming while also following software development best practices. We'll get hands-on experience in writing and publishing a Python Package while using Jupyter Notebooks. In addition to publishing the package, we'll also learn how to deploy the docs, run simple tests and run these tests on CI/CD, making sure that our package will only get published if the tests pass. Even though this tutorial uses Jupyter Notebooks and Nbdev the student doesn't need previous knowledge of these tools. A simple computer with Python and pip installed is all we'll use. Students should have some minimal Python knowledge and Git experience (Simple commands like push, pull, add and commit). A GitHub account will also be necessary.

Python supports multiple programming paradigms. You can write procedural programs, use functional programming features, or use the full power object-oriented programming. In this tutorial you will learn how to get the most out of object-oriented programming. After this tutorial you will able to: - design you own objects - take advantage of inheritance for code re-use - implement special methods for pythonic objects - convert programs from a procedural to a object-oriented approach This tutorial is based on a small but comprehensive example. Starting from a procedural solution with lists and dictionaries, the tutorial gradually introduces how to create own objects to solve the same problem. The next steps introduce the concepts of inheritance and special methods to take full advantage of object-oriented programming.

You can use decorators in your Python code to change the behavior of one or several functions. Many popular libraries are based on decorators. For example, you can use decorators to register functions as web endpoints, mark functions for JIT compilation, or profile your functions. Using decorators makes your code simpler and more readable. However, to unlock the full capability of decorators, you should also be comfortable writing your own. In this tutorial, you'll learn how decorators work under the hood, and you'll get plenty of practice writing your own decorators. You'll be introduced to necessary background information about how functions are first-class objects in Python and how you can define inner functions. You'll learn how to unwrap the @decorator syntactic sugar and how to write solid decorators that you can use in your code. Being comfortable with using and creating decorators will make you a more efficient Python programmer.

Have you been troubled by Python code that took too long to run? Do you want to know why and how to improve? In this workshop, we will introduce Numba - a JIT compiler that is designed to speed up numerical calculations. Most people found all of it is like a mystery - It sounds like magic, but how does it work? Under what conditions does it work? And because of it, new users found it hard to start using it and it requires a steep learning curve to get the hang of it. This workshop will provide all the knowledge that you need to make Numba works for you. This workshop is for Data scientists or developers who have math-heavy code that would like to speed up with the benefit of Numpy and Numba.

You've built an awesome API; time to give it some exposure! But, how do you keep a documentation website up-to-date as your code evolves? This tutorial will teach you how to write, generate, host, automate and version your documentation easily so it becomes part of your software development life cycle.

From Deforestation to Wildlife Trade to Carbon Polluters, learn how to use Python to explore current Eco topics! As Earth's sustainability edges ever closer to tipping point, it has never been more important for us inhabitants to be aware of the impact we have on the environment, and the deteriorating state of our planet. This tutorial will democratize access to practical Python skills for the relevant sciences, applying these skills to pressing Eco issues, and ultimately empower non-subject experts with working proficiency of relevant open-source tools for discovering more facts about our natural world, at a time when disinformation is rife. Key Python takeaways: intro to and/or application of numpy, pandas, matplotlib, networkx, geopandas, xarray, and rioxarray. Format: interactive computer lab, with attendees working hands-on through pre-prepared Jupyter Notebook content at a group pace led by the instructor. Audience: no prior Eco/Scientific domain knowledge or experience with the Python packages being taught required, but attendees must have basic Python programming proficiency and ability to set-up access to JupyterLab with the required mainstream dependencies (as per instructions provided in advance).

OpenTelemetry is a free, open-source Observability Protocol. OpenTelemetry sits at the application layer, and exports Traces, Metrics, and Logs to a backend for observing. It is extremely helpful and beneficial to developers in mean "time-to-detection" and "time-to-resolution" of bugs and issues that occur at the application layer; this ranges from detecting and alerting for errors raised (such as TypeError), to finding that a specific microservice (such as AWS Lambda) ran for twice as long as usual, all the way to seeing the output of a service and comparing it to the expected output to find a bug in the logic of the service. This tutorial is geared towards beginner/intermediate Python developers, who have some experience in Python, its syntax, and very minimal experience in Requests and Flask is needed (extremely popular libraries, with 50k and 60k stars on GitHub, respectively). No OpenTelemetry experience is needed at all. This is a total and complete introduction into OpenTelemetry, consisting instrumenting your first application, viewing your first traces and metrics, and if time-allows then deploying your first Jaeger instance locally (no experience is needed, only Docker desktop), to allow students of this workshop tutorial to build their own in-house observability platform, be-it for their selves or employers. It is important that every developer have at least a solid understanding of Traces, Metrics, and Logs, which we know today as the three pillars of observability. These are the foundational building blocks for monitoring Production environments at the application layer. The extended base workshop is available here and the base slides are available here. Thank you.

Every team implements authorization in their app to control which users can do what. You'd think by now we'd have a standard set of best practices for how to build it. And yet, we don't! Especially in the Python ecosystem. Why is authorization so hard? Authorization is made up of three building blocks, each of which presents its own challenges: 1. Enforcing authorization is hard because it needs to happen in so many places. Controllers, database mappers, routers, and user interfaces all need to enforce authorization. As a result, there are limited off-the-shelf approaches that work in all cases. 2. Decision architecture is hard because you want to separate authorization from the application, but a lot of authorization data is application data too. A monolith can check its own database when it needs to make a decision, but what happens if you want to consolidate authorization into a separate service? Many off-the-shelf solutions focus on the separation – coordinating it and keeping everything in sync is challenging too. 3. Modeling authorization is hard too. It's easy to whip up the first use case — adding a roles table to your database works for a while. But it's hard to start simple and grow into your complexity as you need it. And it's hard to make something powerful that's simple to get started with. The options available typically err on one end of the spectrum or the other. In this talk, you'll learn the approaches for how to solve each of these areas and the associated tradeoffs. Slides: https://pycon-assets.s3.amazonaws.com/2022/media/presentation_slides/11/2022-04-29T22%3A32%3A41.095872/deck-fa3c23.pdf